{-# LANGUAGE AllowAmbiguousTypes   #-}
{-# LANGUAGE DataKinds             #-}
{-# LANGUAGE DeriveAnyClass        #-}
{-# LANGUAGE DeriveDataTypeable    #-}
{-# LANGUAGE DerivingStrategies    #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE LambdaCase            #-}
{-# LANGUAGE NamedFieldPuns        #-}
{-# LANGUAGE OverloadedStrings     #-}
{-# LANGUAGE PolyKinds             #-}
{-# LANGUAGE RecordWildCards       #-}
{-# LANGUAGE TypeFamilies          #-}
{-# LANGUAGE UndecidableInstances  #-}

module PlutusTx.Blueprint.Schema where

import Control.Lens.Plated (Plated)
import Data.Aeson (ToJSON (..), (.=))
import Data.Aeson qualified as Aeson
import Data.Aeson.Extra (optionalField, requiredField)
import Data.Aeson.KeyMap qualified as KeyMap
import Data.ByteString (ByteString)
import Data.ByteString.Base16 qualified as Base16
import Data.Data (Data, Typeable)
import Data.Function ((&))
import Data.Kind (Type)
import Data.List.NonEmpty (NonEmpty, nonEmpty)
import Data.Text (Text)
import Data.Text.Encoding qualified as Text
import GHC.Generics (Generic)
import Numeric.Natural (Natural)
import PlutusTx.Blueprint.Definition.Id (DefinitionId, definitionIdToText)
import PlutusTx.Blueprint.Schema.Annotation (SchemaInfo, comment, description, title)
import Prelude hiding (max, maximum, min, minimum)

{- | Blueprint schema definition, as defined by the CIP-0057:
  https://github.com/cardano-foundation/CIPs/tree/master/CIP-0057#core-vocabulary

  The 'referencedTypes' phantom type parameter is used to track the types used in the contract
  making sure their schemas are included in the blueprint and that they are referenced
  in a type-safe way.
-}
data Schema (referencedTypes :: [Type])
  = SchemaInteger SchemaInfo IntegerSchema
  | SchemaBytes SchemaInfo BytesSchema
  | SchemaList SchemaInfo (ListSchema referencedTypes)
  | SchemaMap SchemaInfo (MapSchema referencedTypes)
  | SchemaConstructor SchemaInfo (ConstructorSchema referencedTypes)
  | SchemaBuiltInData SchemaInfo
  | SchemaBuiltInUnit SchemaInfo
  | SchemaBuiltInBoolean SchemaInfo
  | SchemaBuiltInInteger SchemaInfo
  | SchemaBuiltInBytes SchemaInfo
  | SchemaBuiltInString SchemaInfo
  | SchemaBuiltInPair SchemaInfo (PairSchema referencedTypes)
  | SchemaBuiltInList SchemaInfo (Schema referencedTypes)
  | SchemaOneOf (NonEmpty (Schema referencedTypes))
  | SchemaAnyOf (NonEmpty (Schema referencedTypes))
  | SchemaAllOf (NonEmpty (Schema referencedTypes))
  | SchemaNot (Schema referencedTypes)
  | SchemaDefinitionRef DefinitionId
  deriving stock (Schema referencedTypes -> Schema referencedTypes -> Bool
(Schema referencedTypes -> Schema referencedTypes -> Bool)
-> (Schema referencedTypes -> Schema referencedTypes -> Bool)
-> Eq (Schema referencedTypes)
forall (referencedTypes :: [*]).
Schema referencedTypes -> Schema referencedTypes -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall (referencedTypes :: [*]).
Schema referencedTypes -> Schema referencedTypes -> Bool
== :: Schema referencedTypes -> Schema referencedTypes -> Bool
$c/= :: forall (referencedTypes :: [*]).
Schema referencedTypes -> Schema referencedTypes -> Bool
/= :: Schema referencedTypes -> Schema referencedTypes -> Bool
Eq, Eq (Schema referencedTypes)
Eq (Schema referencedTypes) =>
(Schema referencedTypes -> Schema referencedTypes -> Ordering)
-> (Schema referencedTypes -> Schema referencedTypes -> Bool)
-> (Schema referencedTypes -> Schema referencedTypes -> Bool)
-> (Schema referencedTypes -> Schema referencedTypes -> Bool)
-> (Schema referencedTypes -> Schema referencedTypes -> Bool)
-> (Schema referencedTypes
    -> Schema referencedTypes -> Schema referencedTypes)
-> (Schema referencedTypes
    -> Schema referencedTypes -> Schema referencedTypes)
-> Ord (Schema referencedTypes)
Schema referencedTypes -> Schema referencedTypes -> Bool
Schema referencedTypes -> Schema referencedTypes -> Ordering
Schema referencedTypes
-> Schema referencedTypes -> Schema referencedTypes
forall (referencedTypes :: [*]). Eq (Schema referencedTypes)
forall (referencedTypes :: [*]).
Schema referencedTypes -> Schema referencedTypes -> Bool
forall (referencedTypes :: [*]).
Schema referencedTypes -> Schema referencedTypes -> Ordering
forall (referencedTypes :: [*]).
Schema referencedTypes
-> Schema referencedTypes -> Schema referencedTypes
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 :: forall (referencedTypes :: [*]).
Schema referencedTypes -> Schema referencedTypes -> Ordering
compare :: Schema referencedTypes -> Schema referencedTypes -> Ordering
$c< :: forall (referencedTypes :: [*]).
Schema referencedTypes -> Schema referencedTypes -> Bool
< :: Schema referencedTypes -> Schema referencedTypes -> Bool
$c<= :: forall (referencedTypes :: [*]).
Schema referencedTypes -> Schema referencedTypes -> Bool
<= :: Schema referencedTypes -> Schema referencedTypes -> Bool
$c> :: forall (referencedTypes :: [*]).
Schema referencedTypes -> Schema referencedTypes -> Bool
> :: Schema referencedTypes -> Schema referencedTypes -> Bool
$c>= :: forall (referencedTypes :: [*]).
Schema referencedTypes -> Schema referencedTypes -> Bool
>= :: Schema referencedTypes -> Schema referencedTypes -> Bool
$cmax :: forall (referencedTypes :: [*]).
Schema referencedTypes
-> Schema referencedTypes -> Schema referencedTypes
max :: Schema referencedTypes
-> Schema referencedTypes -> Schema referencedTypes
$cmin :: forall (referencedTypes :: [*]).
Schema referencedTypes
-> Schema referencedTypes -> Schema referencedTypes
min :: Schema referencedTypes
-> Schema referencedTypes -> Schema referencedTypes
Ord, Int -> Schema referencedTypes -> ShowS
[Schema referencedTypes] -> ShowS
Schema referencedTypes -> String
(Int -> Schema referencedTypes -> ShowS)
-> (Schema referencedTypes -> String)
-> ([Schema referencedTypes] -> ShowS)
-> Show (Schema referencedTypes)
forall (referencedTypes :: [*]).
Int -> Schema referencedTypes -> ShowS
forall (referencedTypes :: [*]). [Schema referencedTypes] -> ShowS
forall (referencedTypes :: [*]). Schema referencedTypes -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall (referencedTypes :: [*]).
Int -> Schema referencedTypes -> ShowS
showsPrec :: Int -> Schema referencedTypes -> ShowS
$cshow :: forall (referencedTypes :: [*]). Schema referencedTypes -> String
show :: Schema referencedTypes -> String
$cshowList :: forall (referencedTypes :: [*]). [Schema referencedTypes] -> ShowS
showList :: [Schema referencedTypes] -> ShowS
Show, (forall x.
 Schema referencedTypes -> Rep (Schema referencedTypes) x)
-> (forall x.
    Rep (Schema referencedTypes) x -> Schema referencedTypes)
-> Generic (Schema referencedTypes)
forall (referencedTypes :: [*]) x.
Rep (Schema referencedTypes) x -> Schema referencedTypes
forall (referencedTypes :: [*]) x.
Schema referencedTypes -> Rep (Schema referencedTypes) x
forall x. Rep (Schema referencedTypes) x -> Schema referencedTypes
forall x. Schema referencedTypes -> Rep (Schema referencedTypes) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall (referencedTypes :: [*]) x.
Schema referencedTypes -> Rep (Schema referencedTypes) x
from :: forall x. Schema referencedTypes -> Rep (Schema referencedTypes) x
$cto :: forall (referencedTypes :: [*]) x.
Rep (Schema referencedTypes) x -> Schema referencedTypes
to :: forall x. Rep (Schema referencedTypes) x -> Schema referencedTypes
Generic, Typeable (Schema referencedTypes)
Typeable (Schema referencedTypes) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> Schema referencedTypes
 -> c (Schema referencedTypes))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Schema referencedTypes))
-> (Schema referencedTypes -> Constr)
-> (Schema referencedTypes -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d))
    -> Maybe (c (Schema referencedTypes)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Schema referencedTypes)))
-> ((forall b. Data b => b -> b)
    -> Schema referencedTypes -> Schema referencedTypes)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> Schema referencedTypes
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> Schema referencedTypes
    -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> Schema referencedTypes -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Schema referencedTypes -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> Schema referencedTypes -> m (Schema referencedTypes))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Schema referencedTypes -> m (Schema referencedTypes))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> Schema referencedTypes -> m (Schema referencedTypes))
-> Data (Schema referencedTypes)
Schema referencedTypes -> Constr
Schema referencedTypes -> DataType
(forall b. Data b => b -> b)
-> Schema referencedTypes -> Schema referencedTypes
forall (referencedTypes :: [*]).
Typeable referencedTypes =>
Typeable (Schema referencedTypes)
forall (referencedTypes :: [*]).
Typeable referencedTypes =>
Schema referencedTypes -> Constr
forall (referencedTypes :: [*]).
Typeable referencedTypes =>
Schema referencedTypes -> DataType
forall (referencedTypes :: [*]).
Typeable referencedTypes =>
(forall b. Data b => b -> b)
-> Schema referencedTypes -> Schema referencedTypes
forall (referencedTypes :: [*]) u.
Typeable referencedTypes =>
Int -> (forall d. Data d => d -> u) -> Schema referencedTypes -> u
forall (referencedTypes :: [*]) u.
Typeable referencedTypes =>
(forall d. Data d => d -> u) -> Schema referencedTypes -> [u]
forall (referencedTypes :: [*]) r r'.
Typeable referencedTypes =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> Schema referencedTypes
-> r
forall (referencedTypes :: [*]) r r'.
Typeable referencedTypes =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> Schema referencedTypes
-> r
forall (referencedTypes :: [*]) (m :: * -> *).
(Typeable referencedTypes, Monad m) =>
(forall d. Data d => d -> m d)
-> Schema referencedTypes -> m (Schema referencedTypes)
forall (referencedTypes :: [*]) (m :: * -> *).
(Typeable referencedTypes, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Schema referencedTypes -> m (Schema referencedTypes)
forall (referencedTypes :: [*]) (c :: * -> *).
Typeable referencedTypes =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Schema referencedTypes)
forall (referencedTypes :: [*]) (c :: * -> *).
Typeable referencedTypes =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> Schema referencedTypes
-> c (Schema referencedTypes)
forall (referencedTypes :: [*]) (t :: * -> *) (c :: * -> *).
(Typeable referencedTypes, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Schema referencedTypes))
forall (referencedTypes :: [*]) (t :: * -> * -> *) (c :: * -> *).
(Typeable referencedTypes, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Schema referencedTypes))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> Schema referencedTypes -> u
forall u.
(forall d. Data d => d -> u) -> Schema referencedTypes -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> Schema referencedTypes
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> Schema referencedTypes
-> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Schema referencedTypes -> m (Schema referencedTypes)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Schema referencedTypes -> m (Schema referencedTypes)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Schema referencedTypes)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> Schema referencedTypes
-> c (Schema referencedTypes)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Schema referencedTypes))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Schema referencedTypes))
$cgfoldl :: forall (referencedTypes :: [*]) (c :: * -> *).
Typeable referencedTypes =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> Schema referencedTypes
-> c (Schema referencedTypes)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> Schema referencedTypes
-> c (Schema referencedTypes)
$cgunfold :: forall (referencedTypes :: [*]) (c :: * -> *).
Typeable referencedTypes =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Schema referencedTypes)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Schema referencedTypes)
$ctoConstr :: forall (referencedTypes :: [*]).
Typeable referencedTypes =>
Schema referencedTypes -> Constr
toConstr :: Schema referencedTypes -> Constr
$cdataTypeOf :: forall (referencedTypes :: [*]).
Typeable referencedTypes =>
Schema referencedTypes -> DataType
dataTypeOf :: Schema referencedTypes -> DataType
$cdataCast1 :: forall (referencedTypes :: [*]) (t :: * -> *) (c :: * -> *).
(Typeable referencedTypes, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Schema referencedTypes))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Schema referencedTypes))
$cdataCast2 :: forall (referencedTypes :: [*]) (t :: * -> * -> *) (c :: * -> *).
(Typeable referencedTypes, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Schema referencedTypes))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Schema referencedTypes))
$cgmapT :: forall (referencedTypes :: [*]).
Typeable referencedTypes =>
(forall b. Data b => b -> b)
-> Schema referencedTypes -> Schema referencedTypes
gmapT :: (forall b. Data b => b -> b)
-> Schema referencedTypes -> Schema referencedTypes
$cgmapQl :: forall (referencedTypes :: [*]) r r'.
Typeable referencedTypes =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> Schema referencedTypes
-> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> Schema referencedTypes
-> r
$cgmapQr :: forall (referencedTypes :: [*]) r r'.
Typeable referencedTypes =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> Schema referencedTypes
-> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> Schema referencedTypes
-> r
$cgmapQ :: forall (referencedTypes :: [*]) u.
Typeable referencedTypes =>
(forall d. Data d => d -> u) -> Schema referencedTypes -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> Schema referencedTypes -> [u]
$cgmapQi :: forall (referencedTypes :: [*]) u.
Typeable referencedTypes =>
Int -> (forall d. Data d => d -> u) -> Schema referencedTypes -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> Schema referencedTypes -> u
$cgmapM :: forall (referencedTypes :: [*]) (m :: * -> *).
(Typeable referencedTypes, Monad m) =>
(forall d. Data d => d -> m d)
-> Schema referencedTypes -> m (Schema referencedTypes)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> Schema referencedTypes -> m (Schema referencedTypes)
$cgmapMp :: forall (referencedTypes :: [*]) (m :: * -> *).
(Typeable referencedTypes, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Schema referencedTypes -> m (Schema referencedTypes)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Schema referencedTypes -> m (Schema referencedTypes)
$cgmapMo :: forall (referencedTypes :: [*]) (m :: * -> *).
(Typeable referencedTypes, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> Schema referencedTypes -> m (Schema referencedTypes)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> Schema referencedTypes -> m (Schema referencedTypes)
Data)

deriving anyclass instance (Typeable referencedTypes) => Plated (Schema referencedTypes)

instance ToJSON (Schema referencedTypes) where
  toJSON :: Schema referencedTypes -> Value
toJSON = \case
    SchemaInteger SchemaInfo
info MkIntegerSchema{Maybe Integer
multipleOf :: Maybe Integer
minimum :: Maybe Integer
maximum :: Maybe Integer
exclusiveMinimum :: Maybe Integer
exclusiveMaximum :: Maybe Integer
$sel:multipleOf:MkIntegerSchema :: IntegerSchema -> Maybe Integer
$sel:minimum:MkIntegerSchema :: IntegerSchema -> Maybe Integer
$sel:maximum:MkIntegerSchema :: IntegerSchema -> Maybe Integer
$sel:exclusiveMinimum:MkIntegerSchema :: IntegerSchema -> Maybe Integer
$sel:exclusiveMaximum:MkIntegerSchema :: IntegerSchema -> Maybe Integer
..} ->
      SchemaInfo -> String -> Object
dataType SchemaInfo
info String
"integer"
        Object -> (Object -> Object) -> Object
forall a b. a -> (a -> b) -> b
& Key -> Maybe Integer -> Object -> Object
forall a. ToJSON a => Key -> Maybe a -> Object -> Object
optionalField Key
"multipleOf" Maybe Integer
multipleOf
        Object -> (Object -> Object) -> Object
forall a b. a -> (a -> b) -> b
& Key -> Maybe Integer -> Object -> Object
forall a. ToJSON a => Key -> Maybe a -> Object -> Object
optionalField Key
"minimum" Maybe Integer
minimum
        Object -> (Object -> Object) -> Object
forall a b. a -> (a -> b) -> b
& Key -> Maybe Integer -> Object -> Object
forall a. ToJSON a => Key -> Maybe a -> Object -> Object
optionalField Key
"maximum" Maybe Integer
maximum
        Object -> (Object -> Object) -> Object
forall a b. a -> (a -> b) -> b
& Key -> Maybe Integer -> Object -> Object
forall a. ToJSON a => Key -> Maybe a -> Object -> Object
optionalField Key
"exclusiveMinimum" Maybe Integer
exclusiveMinimum
        Object -> (Object -> Object) -> Object
forall a b. a -> (a -> b) -> b
& Key -> Maybe Integer -> Object -> Object
forall a. ToJSON a => Key -> Maybe a -> Object -> Object
optionalField Key
"exclusiveMaximum" Maybe Integer
exclusiveMaximum
        Object -> (Object -> Value) -> Value
forall a b. a -> (a -> b) -> b
& Object -> Value
Aeson.Object
    SchemaBytes SchemaInfo
info MkBytesSchema{[ByteString]
Maybe Natural
enum :: [ByteString]
minLength :: Maybe Natural
maxLength :: Maybe Natural
$sel:enum:MkBytesSchema :: BytesSchema -> [ByteString]
$sel:minLength:MkBytesSchema :: BytesSchema -> Maybe Natural
$sel:maxLength:MkBytesSchema :: BytesSchema -> Maybe Natural
..} ->
      SchemaInfo -> String -> Object
dataType SchemaInfo
info String
"bytes"
        Object -> (Object -> Object) -> Object
forall a b. a -> (a -> b) -> b
& Key -> Maybe (NonEmpty Text) -> Object -> Object
forall a. ToJSON a => Key -> Maybe a -> Object -> Object
optionalField Key
"enum" ((ByteString -> Text) -> NonEmpty ByteString -> NonEmpty Text
forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteString -> Text
toHex (NonEmpty ByteString -> NonEmpty Text)
-> Maybe (NonEmpty ByteString) -> Maybe (NonEmpty Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [ByteString] -> Maybe (NonEmpty ByteString)
forall a. [a] -> Maybe (NonEmpty a)
nonEmpty [ByteString]
enum)
        Object -> (Object -> Object) -> Object
forall a b. a -> (a -> b) -> b
& Key -> Maybe Natural -> Object -> Object
forall a. ToJSON a => Key -> Maybe a -> Object -> Object
optionalField Key
"maxLength" Maybe Natural
maxLength
        Object -> (Object -> Object) -> Object
forall a b. a -> (a -> b) -> b
& Key -> Maybe Natural -> Object -> Object
forall a. ToJSON a => Key -> Maybe a -> Object -> Object
optionalField Key
"minLength" Maybe Natural
minLength
        Object -> (Object -> Value) -> Value
forall a b. a -> (a -> b) -> b
& Object -> Value
Aeson.Object
     where
      toHex :: ByteString -> Text
      toHex :: ByteString -> Text
toHex = ByteString -> Text
Text.decodeUtf8 (ByteString -> Text)
-> (ByteString -> ByteString) -> ByteString -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
Base16.encode
    SchemaList SchemaInfo
info MkListSchema{Maybe Bool
Maybe Natural
Schema referencedTypes
itemSchema :: Schema referencedTypes
minItems :: Maybe Natural
maxItems :: Maybe Natural
uniqueItems :: Maybe Bool
$sel:itemSchema:MkListSchema :: forall (referencedTypes :: [*]).
ListSchema referencedTypes -> Schema referencedTypes
$sel:minItems:MkListSchema :: forall (referencedTypes :: [*]).
ListSchema referencedTypes -> Maybe Natural
$sel:maxItems:MkListSchema :: forall (referencedTypes :: [*]).
ListSchema referencedTypes -> Maybe Natural
$sel:uniqueItems:MkListSchema :: forall (referencedTypes :: [*]).
ListSchema referencedTypes -> Maybe Bool
..} ->
      SchemaInfo -> String -> Object
dataType SchemaInfo
info String
"list"
        Object -> (Object -> Object) -> Object
forall a b. a -> (a -> b) -> b
& Key -> Schema referencedTypes -> Object -> Object
forall a. ToJSON a => Key -> a -> Object -> Object
requiredField Key
"items" Schema referencedTypes
itemSchema
        Object -> (Object -> Object) -> Object
forall a b. a -> (a -> b) -> b
& Key -> Maybe Natural -> Object -> Object
forall a. ToJSON a => Key -> Maybe a -> Object -> Object
optionalField Key
"minItems" Maybe Natural
minItems
        Object -> (Object -> Object) -> Object
forall a b. a -> (a -> b) -> b
& Key -> Maybe Natural -> Object -> Object
forall a. ToJSON a => Key -> Maybe a -> Object -> Object
optionalField Key
"maxItems" Maybe Natural
maxItems
        Object -> (Object -> Object) -> Object
forall a b. a -> (a -> b) -> b
& Key -> Maybe Bool -> Object -> Object
forall a. ToJSON a => Key -> Maybe a -> Object -> Object
optionalField Key
"uniqueItems" Maybe Bool
uniqueItems
        Object -> (Object -> Value) -> Value
forall a b. a -> (a -> b) -> b
& Object -> Value
Aeson.Object
    SchemaMap SchemaInfo
info MkMapSchema{Maybe Natural
Schema referencedTypes
keySchema :: Schema referencedTypes
valueSchema :: Schema referencedTypes
minItems :: Maybe Natural
maxItems :: Maybe Natural
$sel:keySchema:MkMapSchema :: forall (referencedTypes :: [*]).
MapSchema referencedTypes -> Schema referencedTypes
$sel:valueSchema:MkMapSchema :: forall (referencedTypes :: [*]).
MapSchema referencedTypes -> Schema referencedTypes
$sel:minItems:MkMapSchema :: forall (referencedTypes :: [*]).
MapSchema referencedTypes -> Maybe Natural
$sel:maxItems:MkMapSchema :: forall (referencedTypes :: [*]).
MapSchema referencedTypes -> Maybe Natural
..} ->
      SchemaInfo -> String -> Object
dataType SchemaInfo
info String
"map"
        Object -> (Object -> Object) -> Object
forall a b. a -> (a -> b) -> b
& Key -> Schema referencedTypes -> Object -> Object
forall a. ToJSON a => Key -> a -> Object -> Object
requiredField Key
"keys" Schema referencedTypes
keySchema
        Object -> (Object -> Object) -> Object
forall a b. a -> (a -> b) -> b
& Key -> Schema referencedTypes -> Object -> Object
forall a. ToJSON a => Key -> a -> Object -> Object
requiredField Key
"values" Schema referencedTypes
valueSchema
        Object -> (Object -> Object) -> Object
forall a b. a -> (a -> b) -> b
& Key -> Maybe Natural -> Object -> Object
forall a. ToJSON a => Key -> Maybe a -> Object -> Object
optionalField Key
"minItems" Maybe Natural
minItems
        Object -> (Object -> Object) -> Object
forall a b. a -> (a -> b) -> b
& Key -> Maybe Natural -> Object -> Object
forall a. ToJSON a => Key -> Maybe a -> Object -> Object
optionalField Key
"maxItems" Maybe Natural
maxItems
        Object -> (Object -> Value) -> Value
forall a b. a -> (a -> b) -> b
& Object -> Value
Aeson.Object
    SchemaConstructor SchemaInfo
info MkConstructorSchema{Natural
[Schema referencedTypes]
index :: Natural
fieldSchemas :: [Schema referencedTypes]
$sel:index:MkConstructorSchema :: forall (referencedTypes :: [*]).
ConstructorSchema referencedTypes -> Natural
$sel:fieldSchemas:MkConstructorSchema :: forall (referencedTypes :: [*]).
ConstructorSchema referencedTypes -> [Schema referencedTypes]
..} ->
      SchemaInfo -> String -> Object
dataType SchemaInfo
info String
"constructor"
        Object -> (Object -> Object) -> Object
forall a b. a -> (a -> b) -> b
& Key -> Natural -> Object -> Object
forall a. ToJSON a => Key -> a -> Object -> Object
requiredField Key
"index" Natural
index
        Object -> (Object -> Object) -> Object
forall a b. a -> (a -> b) -> b
& Key -> [Schema referencedTypes] -> Object -> Object
forall a. ToJSON a => Key -> a -> Object -> Object
requiredField Key
"fields" [Schema referencedTypes]
fieldSchemas
        Object -> (Object -> Value) -> Value
forall a b. a -> (a -> b) -> b
& Object -> Value
Aeson.Object
    SchemaBuiltInData SchemaInfo
info ->
      Object -> Value
Aeson.Object (Object -> Value) -> Object -> Value
forall a b. (a -> b) -> a -> b
$ SchemaInfo -> Object
infoFields SchemaInfo
info
    SchemaBuiltInUnit SchemaInfo
info ->
      Object -> Value
Aeson.Object (Object -> Value) -> Object -> Value
forall a b. (a -> b) -> a -> b
$ SchemaInfo -> String -> Object
dataType SchemaInfo
info String
"#unit"
    SchemaBuiltInBoolean SchemaInfo
info ->
      Object -> Value
Aeson.Object (Object -> Value) -> Object -> Value
forall a b. (a -> b) -> a -> b
$ SchemaInfo -> String -> Object
dataType SchemaInfo
info String
"#boolean"
    SchemaBuiltInInteger SchemaInfo
info ->
      Object -> Value
Aeson.Object (Object -> Value) -> Object -> Value
forall a b. (a -> b) -> a -> b
$ SchemaInfo -> String -> Object
dataType SchemaInfo
info String
"#integer"
    SchemaBuiltInBytes SchemaInfo
info ->
      Object -> Value
Aeson.Object (Object -> Value) -> Object -> Value
forall a b. (a -> b) -> a -> b
$ SchemaInfo -> String -> Object
dataType SchemaInfo
info String
"#bytes"
    SchemaBuiltInString SchemaInfo
info ->
      Object -> Value
Aeson.Object (Object -> Value) -> Object -> Value
forall a b. (a -> b) -> a -> b
$ SchemaInfo -> String -> Object
dataType SchemaInfo
info String
"#string"
    SchemaBuiltInPair SchemaInfo
info MkPairSchema{Schema referencedTypes
left :: Schema referencedTypes
$sel:left:MkPairSchema :: forall (referencedTypes :: [*]).
PairSchema referencedTypes -> Schema referencedTypes
left, Schema referencedTypes
right :: Schema referencedTypes
$sel:right:MkPairSchema :: forall (referencedTypes :: [*]).
PairSchema referencedTypes -> Schema referencedTypes
right} ->
      SchemaInfo -> String -> Object
dataType SchemaInfo
info String
"#pair"
        Object -> (Object -> Object) -> Object
forall a b. a -> (a -> b) -> b
& Key -> Schema referencedTypes -> Object -> Object
forall a. ToJSON a => Key -> a -> Object -> Object
requiredField Key
"left" Schema referencedTypes
left
        Object -> (Object -> Object) -> Object
forall a b. a -> (a -> b) -> b
& Key -> Schema referencedTypes -> Object -> Object
forall a. ToJSON a => Key -> a -> Object -> Object
requiredField Key
"right" Schema referencedTypes
right
        Object -> (Object -> Value) -> Value
forall a b. a -> (a -> b) -> b
& Object -> Value
Aeson.Object
    SchemaBuiltInList SchemaInfo
info Schema referencedTypes
schema ->
      SchemaInfo -> String -> Object
dataType SchemaInfo
info String
"#list"
        Object -> (Object -> Object) -> Object
forall a b. a -> (a -> b) -> b
& Key -> Schema referencedTypes -> Object -> Object
forall a. ToJSON a => Key -> a -> Object -> Object
requiredField Key
"items" Schema referencedTypes
schema
        Object -> (Object -> Value) -> Value
forall a b. a -> (a -> b) -> b
& Object -> Value
Aeson.Object
    SchemaOneOf NonEmpty (Schema referencedTypes)
schemas ->
      [Pair] -> Value
Aeson.object [Key
"oneOf" Key -> NonEmpty (Schema referencedTypes) -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= NonEmpty (Schema referencedTypes)
schemas]
    SchemaAnyOf NonEmpty (Schema referencedTypes)
schemas ->
      [Pair] -> Value
Aeson.object [Key
"anyOf" Key -> NonEmpty (Schema referencedTypes) -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= NonEmpty (Schema referencedTypes)
schemas]
    SchemaAllOf NonEmpty (Schema referencedTypes)
schemas ->
      [Pair] -> Value
Aeson.object [Key
"allOf" Key -> NonEmpty (Schema referencedTypes) -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= NonEmpty (Schema referencedTypes)
schemas]
    SchemaNot Schema referencedTypes
schema ->
      [Pair] -> Value
Aeson.object [Key
"not" Key -> Schema referencedTypes -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Schema referencedTypes
schema]
    SchemaDefinitionRef DefinitionId
definitionId ->
      [Pair] -> Value
Aeson.object [Key
"$ref" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Text
"#/definitions/" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> DefinitionId -> Text
definitionIdToText DefinitionId
definitionId)]
   where
    dataType :: SchemaInfo -> String -> Aeson.Object
    dataType :: SchemaInfo -> String -> Object
dataType SchemaInfo
info String
ty = Key -> String -> Object -> Object
forall a. ToJSON a => Key -> a -> Object -> Object
requiredField Key
"dataType" String
ty (SchemaInfo -> Object
infoFields SchemaInfo
info)

    infoFields :: SchemaInfo -> Aeson.Object
    infoFields :: SchemaInfo -> Object
infoFields SchemaInfo
info =
      Object
forall v. KeyMap v
KeyMap.empty
        Object -> (Object -> Object) -> Object
forall a b. a -> (a -> b) -> b
& Key -> Maybe String -> Object -> Object
forall a. ToJSON a => Key -> Maybe a -> Object -> Object
optionalField Key
"title" (SchemaInfo -> Maybe String
title SchemaInfo
info)
        Object -> (Object -> Object) -> Object
forall a b. a -> (a -> b) -> b
& Key -> Maybe String -> Object -> Object
forall a. ToJSON a => Key -> Maybe a -> Object -> Object
optionalField Key
"description" (SchemaInfo -> Maybe String
description SchemaInfo
info)
        Object -> (Object -> Object) -> Object
forall a b. a -> (a -> b) -> b
& Key -> Maybe String -> Object -> Object
forall a. ToJSON a => Key -> Maybe a -> Object -> Object
optionalField Key
"$comment" (SchemaInfo -> Maybe String
comment SchemaInfo
info)

withSchemaInfo :: (SchemaInfo -> SchemaInfo) -> Schema referencedTypes -> Schema referencedTypes
withSchemaInfo :: forall (referencedTypes :: [*]).
(SchemaInfo -> SchemaInfo)
-> Schema referencedTypes -> Schema referencedTypes
withSchemaInfo SchemaInfo -> SchemaInfo
f = \case
  SchemaInteger SchemaInfo
info IntegerSchema
schema -> SchemaInfo -> IntegerSchema -> Schema referencedTypes
forall (referencedTypes :: [*]).
SchemaInfo -> IntegerSchema -> Schema referencedTypes
SchemaInteger (SchemaInfo -> SchemaInfo
f SchemaInfo
info) IntegerSchema
schema
  SchemaBytes SchemaInfo
info BytesSchema
schema -> SchemaInfo -> BytesSchema -> Schema referencedTypes
forall (referencedTypes :: [*]).
SchemaInfo -> BytesSchema -> Schema referencedTypes
SchemaBytes (SchemaInfo -> SchemaInfo
f SchemaInfo
info) BytesSchema
schema
  SchemaList SchemaInfo
info ListSchema referencedTypes
schema -> SchemaInfo -> ListSchema referencedTypes -> Schema referencedTypes
forall (referencedTypes :: [*]).
SchemaInfo -> ListSchema referencedTypes -> Schema referencedTypes
SchemaList (SchemaInfo -> SchemaInfo
f SchemaInfo
info) ListSchema referencedTypes
schema
  SchemaMap SchemaInfo
info MapSchema referencedTypes
schema -> SchemaInfo -> MapSchema referencedTypes -> Schema referencedTypes
forall (referencedTypes :: [*]).
SchemaInfo -> MapSchema referencedTypes -> Schema referencedTypes
SchemaMap (SchemaInfo -> SchemaInfo
f SchemaInfo
info) MapSchema referencedTypes
schema
  SchemaConstructor SchemaInfo
info ConstructorSchema referencedTypes
schema -> SchemaInfo
-> ConstructorSchema referencedTypes -> Schema referencedTypes
forall (referencedTypes :: [*]).
SchemaInfo
-> ConstructorSchema referencedTypes -> Schema referencedTypes
SchemaConstructor (SchemaInfo -> SchemaInfo
f SchemaInfo
info) ConstructorSchema referencedTypes
schema
  SchemaBuiltInData SchemaInfo
info -> SchemaInfo -> Schema referencedTypes
forall (referencedTypes :: [*]).
SchemaInfo -> Schema referencedTypes
SchemaBuiltInData (SchemaInfo -> SchemaInfo
f SchemaInfo
info)
  SchemaBuiltInUnit SchemaInfo
info -> SchemaInfo -> Schema referencedTypes
forall (referencedTypes :: [*]).
SchemaInfo -> Schema referencedTypes
SchemaBuiltInUnit (SchemaInfo -> SchemaInfo
f SchemaInfo
info)
  SchemaBuiltInBoolean SchemaInfo
info -> SchemaInfo -> Schema referencedTypes
forall (referencedTypes :: [*]).
SchemaInfo -> Schema referencedTypes
SchemaBuiltInBoolean (SchemaInfo -> SchemaInfo
f SchemaInfo
info)
  SchemaBuiltInInteger SchemaInfo
info -> SchemaInfo -> Schema referencedTypes
forall (referencedTypes :: [*]).
SchemaInfo -> Schema referencedTypes
SchemaBuiltInInteger (SchemaInfo -> SchemaInfo
f SchemaInfo
info)
  SchemaBuiltInBytes SchemaInfo
info -> SchemaInfo -> Schema referencedTypes
forall (referencedTypes :: [*]).
SchemaInfo -> Schema referencedTypes
SchemaBuiltInBytes (SchemaInfo -> SchemaInfo
f SchemaInfo
info)
  SchemaBuiltInString SchemaInfo
info -> SchemaInfo -> Schema referencedTypes
forall (referencedTypes :: [*]).
SchemaInfo -> Schema referencedTypes
SchemaBuiltInString (SchemaInfo -> SchemaInfo
f SchemaInfo
info)
  SchemaBuiltInPair SchemaInfo
info PairSchema referencedTypes
schema -> SchemaInfo -> PairSchema referencedTypes -> Schema referencedTypes
forall (referencedTypes :: [*]).
SchemaInfo -> PairSchema referencedTypes -> Schema referencedTypes
SchemaBuiltInPair (SchemaInfo -> SchemaInfo
f SchemaInfo
info) PairSchema referencedTypes
schema
  SchemaBuiltInList SchemaInfo
info Schema referencedTypes
schema -> SchemaInfo -> Schema referencedTypes -> Schema referencedTypes
forall (referencedTypes :: [*]).
SchemaInfo -> Schema referencedTypes -> Schema referencedTypes
SchemaBuiltInList (SchemaInfo -> SchemaInfo
f SchemaInfo
info) Schema referencedTypes
schema
  SchemaOneOf NonEmpty (Schema referencedTypes)
schemas -> NonEmpty (Schema referencedTypes) -> Schema referencedTypes
forall (referencedTypes :: [*]).
NonEmpty (Schema referencedTypes) -> Schema referencedTypes
SchemaOneOf NonEmpty (Schema referencedTypes)
schemas
  SchemaAnyOf NonEmpty (Schema referencedTypes)
schemas -> NonEmpty (Schema referencedTypes) -> Schema referencedTypes
forall (referencedTypes :: [*]).
NonEmpty (Schema referencedTypes) -> Schema referencedTypes
SchemaAnyOf NonEmpty (Schema referencedTypes)
schemas
  SchemaAllOf NonEmpty (Schema referencedTypes)
schemas -> NonEmpty (Schema referencedTypes) -> Schema referencedTypes
forall (referencedTypes :: [*]).
NonEmpty (Schema referencedTypes) -> Schema referencedTypes
SchemaAllOf NonEmpty (Schema referencedTypes)
schemas
  SchemaNot Schema referencedTypes
schema -> Schema referencedTypes -> Schema referencedTypes
forall (referencedTypes :: [*]).
Schema referencedTypes -> Schema referencedTypes
SchemaNot Schema referencedTypes
schema
  SchemaDefinitionRef DefinitionId
definitionId -> DefinitionId -> Schema referencedTypes
forall (referencedTypes :: [*]).
DefinitionId -> Schema referencedTypes
SchemaDefinitionRef DefinitionId
definitionId

data IntegerSchema = MkIntegerSchema
  { IntegerSchema -> Maybe Integer
multipleOf       :: Maybe Integer
  -- ^ An instance is valid if division by this value results in an integer.
  , IntegerSchema -> Maybe Integer
minimum          :: Maybe Integer
  -- ^ An instance is valid only if it is greater than or exactly equal to "minimum".
  , IntegerSchema -> Maybe Integer
maximum          :: Maybe Integer
  -- ^ An instance is valid only if it is less than or exactly equal to "maximum".
  , IntegerSchema -> Maybe Integer
exclusiveMinimum :: Maybe Integer
  -- ^ An instance is valid only if it is strictly greater than "exclusiveMinimum".
  , IntegerSchema -> Maybe Integer
exclusiveMaximum :: Maybe Integer
  -- ^ An instance is valid only if it is strictly less than "exclusiveMaximum".
  }
  deriving stock (IntegerSchema -> IntegerSchema -> Bool
(IntegerSchema -> IntegerSchema -> Bool)
-> (IntegerSchema -> IntegerSchema -> Bool) -> Eq IntegerSchema
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IntegerSchema -> IntegerSchema -> Bool
== :: IntegerSchema -> IntegerSchema -> Bool
$c/= :: IntegerSchema -> IntegerSchema -> Bool
/= :: IntegerSchema -> IntegerSchema -> Bool
Eq, Eq IntegerSchema
Eq IntegerSchema =>
(IntegerSchema -> IntegerSchema -> Ordering)
-> (IntegerSchema -> IntegerSchema -> Bool)
-> (IntegerSchema -> IntegerSchema -> Bool)
-> (IntegerSchema -> IntegerSchema -> Bool)
-> (IntegerSchema -> IntegerSchema -> Bool)
-> (IntegerSchema -> IntegerSchema -> IntegerSchema)
-> (IntegerSchema -> IntegerSchema -> IntegerSchema)
-> Ord IntegerSchema
IntegerSchema -> IntegerSchema -> Bool
IntegerSchema -> IntegerSchema -> Ordering
IntegerSchema -> IntegerSchema -> IntegerSchema
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 :: IntegerSchema -> IntegerSchema -> Ordering
compare :: IntegerSchema -> IntegerSchema -> Ordering
$c< :: IntegerSchema -> IntegerSchema -> Bool
< :: IntegerSchema -> IntegerSchema -> Bool
$c<= :: IntegerSchema -> IntegerSchema -> Bool
<= :: IntegerSchema -> IntegerSchema -> Bool
$c> :: IntegerSchema -> IntegerSchema -> Bool
> :: IntegerSchema -> IntegerSchema -> Bool
$c>= :: IntegerSchema -> IntegerSchema -> Bool
>= :: IntegerSchema -> IntegerSchema -> Bool
$cmax :: IntegerSchema -> IntegerSchema -> IntegerSchema
max :: IntegerSchema -> IntegerSchema -> IntegerSchema
$cmin :: IntegerSchema -> IntegerSchema -> IntegerSchema
min :: IntegerSchema -> IntegerSchema -> IntegerSchema
Ord, Int -> IntegerSchema -> ShowS
[IntegerSchema] -> ShowS
IntegerSchema -> String
(Int -> IntegerSchema -> ShowS)
-> (IntegerSchema -> String)
-> ([IntegerSchema] -> ShowS)
-> Show IntegerSchema
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IntegerSchema -> ShowS
showsPrec :: Int -> IntegerSchema -> ShowS
$cshow :: IntegerSchema -> String
show :: IntegerSchema -> String
$cshowList :: [IntegerSchema] -> ShowS
showList :: [IntegerSchema] -> ShowS
Show, (forall x. IntegerSchema -> Rep IntegerSchema x)
-> (forall x. Rep IntegerSchema x -> IntegerSchema)
-> Generic IntegerSchema
forall x. Rep IntegerSchema x -> IntegerSchema
forall x. IntegerSchema -> Rep IntegerSchema x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. IntegerSchema -> Rep IntegerSchema x
from :: forall x. IntegerSchema -> Rep IntegerSchema x
$cto :: forall x. Rep IntegerSchema x -> IntegerSchema
to :: forall x. Rep IntegerSchema x -> IntegerSchema
Generic, Typeable IntegerSchema
Typeable IntegerSchema =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> IntegerSchema -> c IntegerSchema)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c IntegerSchema)
-> (IntegerSchema -> Constr)
-> (IntegerSchema -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c IntegerSchema))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c IntegerSchema))
-> ((forall b. Data b => b -> b) -> IntegerSchema -> IntegerSchema)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> IntegerSchema -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> IntegerSchema -> r)
-> (forall u. (forall d. Data d => d -> u) -> IntegerSchema -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> IntegerSchema -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> IntegerSchema -> m IntegerSchema)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> IntegerSchema -> m IntegerSchema)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> IntegerSchema -> m IntegerSchema)
-> Data IntegerSchema
IntegerSchema -> Constr
IntegerSchema -> DataType
(forall b. Data b => b -> b) -> IntegerSchema -> IntegerSchema
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> IntegerSchema -> u
forall u. (forall d. Data d => d -> u) -> IntegerSchema -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IntegerSchema -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IntegerSchema -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IntegerSchema -> m IntegerSchema
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IntegerSchema -> m IntegerSchema
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IntegerSchema
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IntegerSchema -> c IntegerSchema
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IntegerSchema)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c IntegerSchema)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IntegerSchema -> c IntegerSchema
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IntegerSchema -> c IntegerSchema
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IntegerSchema
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IntegerSchema
$ctoConstr :: IntegerSchema -> Constr
toConstr :: IntegerSchema -> Constr
$cdataTypeOf :: IntegerSchema -> DataType
dataTypeOf :: IntegerSchema -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IntegerSchema)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IntegerSchema)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c IntegerSchema)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c IntegerSchema)
$cgmapT :: (forall b. Data b => b -> b) -> IntegerSchema -> IntegerSchema
gmapT :: (forall b. Data b => b -> b) -> IntegerSchema -> IntegerSchema
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IntegerSchema -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IntegerSchema -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IntegerSchema -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IntegerSchema -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> IntegerSchema -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> IntegerSchema -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> IntegerSchema -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> IntegerSchema -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IntegerSchema -> m IntegerSchema
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IntegerSchema -> m IntegerSchema
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IntegerSchema -> m IntegerSchema
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IntegerSchema -> m IntegerSchema
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IntegerSchema -> m IntegerSchema
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IntegerSchema -> m IntegerSchema
Data)

emptyIntegerSchema :: IntegerSchema
emptyIntegerSchema :: IntegerSchema
emptyIntegerSchema =
  MkIntegerSchema
    { $sel:multipleOf:MkIntegerSchema :: Maybe Integer
multipleOf = Maybe Integer
forall a. Maybe a
Nothing
    , $sel:minimum:MkIntegerSchema :: Maybe Integer
minimum = Maybe Integer
forall a. Maybe a
Nothing
    , $sel:maximum:MkIntegerSchema :: Maybe Integer
maximum = Maybe Integer
forall a. Maybe a
Nothing
    , $sel:exclusiveMinimum:MkIntegerSchema :: Maybe Integer
exclusiveMinimum = Maybe Integer
forall a. Maybe a
Nothing
    , $sel:exclusiveMaximum:MkIntegerSchema :: Maybe Integer
exclusiveMaximum = Maybe Integer
forall a. Maybe a
Nothing
    }

data BytesSchema = MkBytesSchema
  { BytesSchema -> [ByteString]
enum      :: [ByteString]
  -- ^ An instance validates successfully if once hex-encoded,
  -- its value matches one of the specified values.
  , BytesSchema -> Maybe Natural
minLength :: Maybe Natural
  -- ^ An instance is valid if its length is greater than, or equal to, this value.
  , BytesSchema -> Maybe Natural
maxLength :: Maybe Natural
  -- ^ An instance is valid if its length is less than, or equal to, this value.
  }
  deriving stock (BytesSchema -> BytesSchema -> Bool
(BytesSchema -> BytesSchema -> Bool)
-> (BytesSchema -> BytesSchema -> Bool) -> Eq BytesSchema
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BytesSchema -> BytesSchema -> Bool
== :: BytesSchema -> BytesSchema -> Bool
$c/= :: BytesSchema -> BytesSchema -> Bool
/= :: BytesSchema -> BytesSchema -> Bool
Eq, Eq BytesSchema
Eq BytesSchema =>
(BytesSchema -> BytesSchema -> Ordering)
-> (BytesSchema -> BytesSchema -> Bool)
-> (BytesSchema -> BytesSchema -> Bool)
-> (BytesSchema -> BytesSchema -> Bool)
-> (BytesSchema -> BytesSchema -> Bool)
-> (BytesSchema -> BytesSchema -> BytesSchema)
-> (BytesSchema -> BytesSchema -> BytesSchema)
-> Ord BytesSchema
BytesSchema -> BytesSchema -> Bool
BytesSchema -> BytesSchema -> Ordering
BytesSchema -> BytesSchema -> BytesSchema
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 :: BytesSchema -> BytesSchema -> Ordering
compare :: BytesSchema -> BytesSchema -> Ordering
$c< :: BytesSchema -> BytesSchema -> Bool
< :: BytesSchema -> BytesSchema -> Bool
$c<= :: BytesSchema -> BytesSchema -> Bool
<= :: BytesSchema -> BytesSchema -> Bool
$c> :: BytesSchema -> BytesSchema -> Bool
> :: BytesSchema -> BytesSchema -> Bool
$c>= :: BytesSchema -> BytesSchema -> Bool
>= :: BytesSchema -> BytesSchema -> Bool
$cmax :: BytesSchema -> BytesSchema -> BytesSchema
max :: BytesSchema -> BytesSchema -> BytesSchema
$cmin :: BytesSchema -> BytesSchema -> BytesSchema
min :: BytesSchema -> BytesSchema -> BytesSchema
Ord, Int -> BytesSchema -> ShowS
[BytesSchema] -> ShowS
BytesSchema -> String
(Int -> BytesSchema -> ShowS)
-> (BytesSchema -> String)
-> ([BytesSchema] -> ShowS)
-> Show BytesSchema
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BytesSchema -> ShowS
showsPrec :: Int -> BytesSchema -> ShowS
$cshow :: BytesSchema -> String
show :: BytesSchema -> String
$cshowList :: [BytesSchema] -> ShowS
showList :: [BytesSchema] -> ShowS
Show, (forall x. BytesSchema -> Rep BytesSchema x)
-> (forall x. Rep BytesSchema x -> BytesSchema)
-> Generic BytesSchema
forall x. Rep BytesSchema x -> BytesSchema
forall x. BytesSchema -> Rep BytesSchema x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. BytesSchema -> Rep BytesSchema x
from :: forall x. BytesSchema -> Rep BytesSchema x
$cto :: forall x. Rep BytesSchema x -> BytesSchema
to :: forall x. Rep BytesSchema x -> BytesSchema
Generic, Typeable BytesSchema
Typeable BytesSchema =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> BytesSchema -> c BytesSchema)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BytesSchema)
-> (BytesSchema -> Constr)
-> (BytesSchema -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BytesSchema))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c BytesSchema))
-> ((forall b. Data b => b -> b) -> BytesSchema -> BytesSchema)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BytesSchema -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BytesSchema -> r)
-> (forall u. (forall d. Data d => d -> u) -> BytesSchema -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> BytesSchema -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BytesSchema -> m BytesSchema)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BytesSchema -> m BytesSchema)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BytesSchema -> m BytesSchema)
-> Data BytesSchema
BytesSchema -> Constr
BytesSchema -> DataType
(forall b. Data b => b -> b) -> BytesSchema -> BytesSchema
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> BytesSchema -> u
forall u. (forall d. Data d => d -> u) -> BytesSchema -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BytesSchema -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BytesSchema -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BytesSchema -> m BytesSchema
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BytesSchema -> m BytesSchema
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BytesSchema
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BytesSchema -> c BytesSchema
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BytesSchema)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BytesSchema)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BytesSchema -> c BytesSchema
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BytesSchema -> c BytesSchema
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BytesSchema
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BytesSchema
$ctoConstr :: BytesSchema -> Constr
toConstr :: BytesSchema -> Constr
$cdataTypeOf :: BytesSchema -> DataType
dataTypeOf :: BytesSchema -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BytesSchema)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BytesSchema)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BytesSchema)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BytesSchema)
$cgmapT :: (forall b. Data b => b -> b) -> BytesSchema -> BytesSchema
gmapT :: (forall b. Data b => b -> b) -> BytesSchema -> BytesSchema
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BytesSchema -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BytesSchema -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BytesSchema -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BytesSchema -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BytesSchema -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> BytesSchema -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BytesSchema -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BytesSchema -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BytesSchema -> m BytesSchema
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BytesSchema -> m BytesSchema
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BytesSchema -> m BytesSchema
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BytesSchema -> m BytesSchema
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BytesSchema -> m BytesSchema
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BytesSchema -> m BytesSchema
Data)

emptyBytesSchema :: BytesSchema
emptyBytesSchema :: BytesSchema
emptyBytesSchema = MkBytesSchema{$sel:enum:MkBytesSchema :: [ByteString]
enum = [], $sel:minLength:MkBytesSchema :: Maybe Natural
minLength = Maybe Natural
forall a. Maybe a
Nothing, $sel:maxLength:MkBytesSchema :: Maybe Natural
maxLength = Maybe Natural
forall a. Maybe a
Nothing}

data ListSchema (referencedTypes :: [Type]) = MkListSchema
  { forall (referencedTypes :: [*]).
ListSchema referencedTypes -> Schema referencedTypes
itemSchema  :: Schema referencedTypes
  -- ^ Element schema
  , forall (referencedTypes :: [*]).
ListSchema referencedTypes -> Maybe Natural
minItems    :: Maybe Natural
  -- ^ An array instance is valid if its size is greater than, or equal to, this value.
  , forall (referencedTypes :: [*]).
ListSchema referencedTypes -> Maybe Natural
maxItems    :: Maybe Natural
  -- ^ An array instance is valid if its size is less than, or equal to, this value.
  , forall (referencedTypes :: [*]).
ListSchema referencedTypes -> Maybe Bool
uniqueItems :: Maybe Bool
  -- ^ If this value is false, the instance validates successfully.
  -- If it is set to True, the instance validates successfully if all of its elements are unique.
  }
  deriving stock (ListSchema referencedTypes -> ListSchema referencedTypes -> Bool
(ListSchema referencedTypes -> ListSchema referencedTypes -> Bool)
-> (ListSchema referencedTypes
    -> ListSchema referencedTypes -> Bool)
-> Eq (ListSchema referencedTypes)
forall (referencedTypes :: [*]).
ListSchema referencedTypes -> ListSchema referencedTypes -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall (referencedTypes :: [*]).
ListSchema referencedTypes -> ListSchema referencedTypes -> Bool
== :: ListSchema referencedTypes -> ListSchema referencedTypes -> Bool
$c/= :: forall (referencedTypes :: [*]).
ListSchema referencedTypes -> ListSchema referencedTypes -> Bool
/= :: ListSchema referencedTypes -> ListSchema referencedTypes -> Bool
Eq, Eq (ListSchema referencedTypes)
Eq (ListSchema referencedTypes) =>
(ListSchema referencedTypes
 -> ListSchema referencedTypes -> Ordering)
-> (ListSchema referencedTypes
    -> ListSchema referencedTypes -> Bool)
-> (ListSchema referencedTypes
    -> ListSchema referencedTypes -> Bool)
-> (ListSchema referencedTypes
    -> ListSchema referencedTypes -> Bool)
-> (ListSchema referencedTypes
    -> ListSchema referencedTypes -> Bool)
-> (ListSchema referencedTypes
    -> ListSchema referencedTypes -> ListSchema referencedTypes)
-> (ListSchema referencedTypes
    -> ListSchema referencedTypes -> ListSchema referencedTypes)
-> Ord (ListSchema referencedTypes)
ListSchema referencedTypes -> ListSchema referencedTypes -> Bool
ListSchema referencedTypes
-> ListSchema referencedTypes -> Ordering
ListSchema referencedTypes
-> ListSchema referencedTypes -> ListSchema referencedTypes
forall (referencedTypes :: [*]). Eq (ListSchema referencedTypes)
forall (referencedTypes :: [*]).
ListSchema referencedTypes -> ListSchema referencedTypes -> Bool
forall (referencedTypes :: [*]).
ListSchema referencedTypes
-> ListSchema referencedTypes -> Ordering
forall (referencedTypes :: [*]).
ListSchema referencedTypes
-> ListSchema referencedTypes -> ListSchema referencedTypes
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 :: forall (referencedTypes :: [*]).
ListSchema referencedTypes
-> ListSchema referencedTypes -> Ordering
compare :: ListSchema referencedTypes
-> ListSchema referencedTypes -> Ordering
$c< :: forall (referencedTypes :: [*]).
ListSchema referencedTypes -> ListSchema referencedTypes -> Bool
< :: ListSchema referencedTypes -> ListSchema referencedTypes -> Bool
$c<= :: forall (referencedTypes :: [*]).
ListSchema referencedTypes -> ListSchema referencedTypes -> Bool
<= :: ListSchema referencedTypes -> ListSchema referencedTypes -> Bool
$c> :: forall (referencedTypes :: [*]).
ListSchema referencedTypes -> ListSchema referencedTypes -> Bool
> :: ListSchema referencedTypes -> ListSchema referencedTypes -> Bool
$c>= :: forall (referencedTypes :: [*]).
ListSchema referencedTypes -> ListSchema referencedTypes -> Bool
>= :: ListSchema referencedTypes -> ListSchema referencedTypes -> Bool
$cmax :: forall (referencedTypes :: [*]).
ListSchema referencedTypes
-> ListSchema referencedTypes -> ListSchema referencedTypes
max :: ListSchema referencedTypes
-> ListSchema referencedTypes -> ListSchema referencedTypes
$cmin :: forall (referencedTypes :: [*]).
ListSchema referencedTypes
-> ListSchema referencedTypes -> ListSchema referencedTypes
min :: ListSchema referencedTypes
-> ListSchema referencedTypes -> ListSchema referencedTypes
Ord, Int -> ListSchema referencedTypes -> ShowS
[ListSchema referencedTypes] -> ShowS
ListSchema referencedTypes -> String
(Int -> ListSchema referencedTypes -> ShowS)
-> (ListSchema referencedTypes -> String)
-> ([ListSchema referencedTypes] -> ShowS)
-> Show (ListSchema referencedTypes)
forall (referencedTypes :: [*]).
Int -> ListSchema referencedTypes -> ShowS
forall (referencedTypes :: [*]).
[ListSchema referencedTypes] -> ShowS
forall (referencedTypes :: [*]).
ListSchema referencedTypes -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall (referencedTypes :: [*]).
Int -> ListSchema referencedTypes -> ShowS
showsPrec :: Int -> ListSchema referencedTypes -> ShowS
$cshow :: forall (referencedTypes :: [*]).
ListSchema referencedTypes -> String
show :: ListSchema referencedTypes -> String
$cshowList :: forall (referencedTypes :: [*]).
[ListSchema referencedTypes] -> ShowS
showList :: [ListSchema referencedTypes] -> ShowS
Show, (forall x.
 ListSchema referencedTypes -> Rep (ListSchema referencedTypes) x)
-> (forall x.
    Rep (ListSchema referencedTypes) x -> ListSchema referencedTypes)
-> Generic (ListSchema referencedTypes)
forall (referencedTypes :: [*]) x.
Rep (ListSchema referencedTypes) x -> ListSchema referencedTypes
forall (referencedTypes :: [*]) x.
ListSchema referencedTypes -> Rep (ListSchema referencedTypes) x
forall x.
Rep (ListSchema referencedTypes) x -> ListSchema referencedTypes
forall x.
ListSchema referencedTypes -> Rep (ListSchema referencedTypes) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall (referencedTypes :: [*]) x.
ListSchema referencedTypes -> Rep (ListSchema referencedTypes) x
from :: forall x.
ListSchema referencedTypes -> Rep (ListSchema referencedTypes) x
$cto :: forall (referencedTypes :: [*]) x.
Rep (ListSchema referencedTypes) x -> ListSchema referencedTypes
to :: forall x.
Rep (ListSchema referencedTypes) x -> ListSchema referencedTypes
Generic, Typeable (ListSchema referencedTypes)
Typeable (ListSchema referencedTypes) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> ListSchema referencedTypes
 -> c (ListSchema referencedTypes))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r)
    -> Constr
    -> c (ListSchema referencedTypes))
-> (ListSchema referencedTypes -> Constr)
-> (ListSchema referencedTypes -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d))
    -> Maybe (c (ListSchema referencedTypes)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ListSchema referencedTypes)))
-> ((forall b. Data b => b -> b)
    -> ListSchema referencedTypes -> ListSchema referencedTypes)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> ListSchema referencedTypes
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> ListSchema referencedTypes
    -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ListSchema referencedTypes -> [u])
-> (forall u.
    Int
    -> (forall d. Data d => d -> u) -> ListSchema referencedTypes -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ListSchema referencedTypes -> m (ListSchema referencedTypes))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ListSchema referencedTypes -> m (ListSchema referencedTypes))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ListSchema referencedTypes -> m (ListSchema referencedTypes))
-> Data (ListSchema referencedTypes)
ListSchema referencedTypes -> Constr
ListSchema referencedTypes -> DataType
(forall b. Data b => b -> b)
-> ListSchema referencedTypes -> ListSchema referencedTypes
forall (referencedTypes :: [*]).
Typeable referencedTypes =>
Typeable (ListSchema referencedTypes)
forall (referencedTypes :: [*]).
Typeable referencedTypes =>
ListSchema referencedTypes -> Constr
forall (referencedTypes :: [*]).
Typeable referencedTypes =>
ListSchema referencedTypes -> DataType
forall (referencedTypes :: [*]).
Typeable referencedTypes =>
(forall b. Data b => b -> b)
-> ListSchema referencedTypes -> ListSchema referencedTypes
forall (referencedTypes :: [*]) u.
Typeable referencedTypes =>
Int
-> (forall d. Data d => d -> u) -> ListSchema referencedTypes -> u
forall (referencedTypes :: [*]) u.
Typeable referencedTypes =>
(forall d. Data d => d -> u) -> ListSchema referencedTypes -> [u]
forall (referencedTypes :: [*]) r r'.
Typeable referencedTypes =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> ListSchema referencedTypes
-> r
forall (referencedTypes :: [*]) r r'.
Typeable referencedTypes =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> ListSchema referencedTypes
-> r
forall (referencedTypes :: [*]) (m :: * -> *).
(Typeable referencedTypes, Monad m) =>
(forall d. Data d => d -> m d)
-> ListSchema referencedTypes -> m (ListSchema referencedTypes)
forall (referencedTypes :: [*]) (m :: * -> *).
(Typeable referencedTypes, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ListSchema referencedTypes -> m (ListSchema referencedTypes)
forall (referencedTypes :: [*]) (c :: * -> *).
Typeable referencedTypes =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ListSchema referencedTypes)
forall (referencedTypes :: [*]) (c :: * -> *).
Typeable referencedTypes =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ListSchema referencedTypes
-> c (ListSchema referencedTypes)
forall (referencedTypes :: [*]) (t :: * -> *) (c :: * -> *).
(Typeable referencedTypes, Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (ListSchema referencedTypes))
forall (referencedTypes :: [*]) (t :: * -> * -> *) (c :: * -> *).
(Typeable referencedTypes, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ListSchema referencedTypes))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int
-> (forall d. Data d => d -> u) -> ListSchema referencedTypes -> u
forall u.
(forall d. Data d => d -> u) -> ListSchema referencedTypes -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> ListSchema referencedTypes
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> ListSchema referencedTypes
-> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ListSchema referencedTypes -> m (ListSchema referencedTypes)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ListSchema referencedTypes -> m (ListSchema referencedTypes)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ListSchema referencedTypes)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ListSchema referencedTypes
-> c (ListSchema referencedTypes)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c (ListSchema referencedTypes))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ListSchema referencedTypes))
$cgfoldl :: forall (referencedTypes :: [*]) (c :: * -> *).
Typeable referencedTypes =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ListSchema referencedTypes
-> c (ListSchema referencedTypes)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ListSchema referencedTypes
-> c (ListSchema referencedTypes)
$cgunfold :: forall (referencedTypes :: [*]) (c :: * -> *).
Typeable referencedTypes =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ListSchema referencedTypes)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ListSchema referencedTypes)
$ctoConstr :: forall (referencedTypes :: [*]).
Typeable referencedTypes =>
ListSchema referencedTypes -> Constr
toConstr :: ListSchema referencedTypes -> Constr
$cdataTypeOf :: forall (referencedTypes :: [*]).
Typeable referencedTypes =>
ListSchema referencedTypes -> DataType
dataTypeOf :: ListSchema referencedTypes -> DataType
$cdataCast1 :: forall (referencedTypes :: [*]) (t :: * -> *) (c :: * -> *).
(Typeable referencedTypes, Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (ListSchema referencedTypes))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c (ListSchema referencedTypes))
$cdataCast2 :: forall (referencedTypes :: [*]) (t :: * -> * -> *) (c :: * -> *).
(Typeable referencedTypes, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ListSchema referencedTypes))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ListSchema referencedTypes))
$cgmapT :: forall (referencedTypes :: [*]).
Typeable referencedTypes =>
(forall b. Data b => b -> b)
-> ListSchema referencedTypes -> ListSchema referencedTypes
gmapT :: (forall b. Data b => b -> b)
-> ListSchema referencedTypes -> ListSchema referencedTypes
$cgmapQl :: forall (referencedTypes :: [*]) r r'.
Typeable referencedTypes =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> ListSchema referencedTypes
-> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> ListSchema referencedTypes
-> r
$cgmapQr :: forall (referencedTypes :: [*]) r r'.
Typeable referencedTypes =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> ListSchema referencedTypes
-> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> ListSchema referencedTypes
-> r
$cgmapQ :: forall (referencedTypes :: [*]) u.
Typeable referencedTypes =>
(forall d. Data d => d -> u) -> ListSchema referencedTypes -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> ListSchema referencedTypes -> [u]
$cgmapQi :: forall (referencedTypes :: [*]) u.
Typeable referencedTypes =>
Int
-> (forall d. Data d => d -> u) -> ListSchema referencedTypes -> u
gmapQi :: forall u.
Int
-> (forall d. Data d => d -> u) -> ListSchema referencedTypes -> u
$cgmapM :: forall (referencedTypes :: [*]) (m :: * -> *).
(Typeable referencedTypes, Monad m) =>
(forall d. Data d => d -> m d)
-> ListSchema referencedTypes -> m (ListSchema referencedTypes)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ListSchema referencedTypes -> m (ListSchema referencedTypes)
$cgmapMp :: forall (referencedTypes :: [*]) (m :: * -> *).
(Typeable referencedTypes, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ListSchema referencedTypes -> m (ListSchema referencedTypes)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ListSchema referencedTypes -> m (ListSchema referencedTypes)
$cgmapMo :: forall (referencedTypes :: [*]) (m :: * -> *).
(Typeable referencedTypes, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ListSchema referencedTypes -> m (ListSchema referencedTypes)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ListSchema referencedTypes -> m (ListSchema referencedTypes)
Data)

mkListSchema :: Schema referencedTypes -> ListSchema referencedTypes
mkListSchema :: forall (referencedTypes :: [*]).
Schema referencedTypes -> ListSchema referencedTypes
mkListSchema Schema referencedTypes
itemSchema =
  MkListSchema
    { Schema referencedTypes
$sel:itemSchema:MkListSchema :: Schema referencedTypes
itemSchema :: Schema referencedTypes
itemSchema
    , $sel:minItems:MkListSchema :: Maybe Natural
minItems = Maybe Natural
forall a. Maybe a
Nothing
    , $sel:maxItems:MkListSchema :: Maybe Natural
maxItems = Maybe Natural
forall a. Maybe a
Nothing
    , $sel:uniqueItems:MkListSchema :: Maybe Bool
uniqueItems = Maybe Bool
forall a. Maybe a
Nothing
    }

data MapSchema (referencedTypes :: [Type]) = MkMapSchema
  { forall (referencedTypes :: [*]).
MapSchema referencedTypes -> Schema referencedTypes
keySchema   :: Schema referencedTypes
  -- ^ Key schema
  , forall (referencedTypes :: [*]).
MapSchema referencedTypes -> Schema referencedTypes
valueSchema :: Schema referencedTypes
  -- ^ Value schema
  , forall (referencedTypes :: [*]).
MapSchema referencedTypes -> Maybe Natural
minItems    :: Maybe Natural
  -- ^ A map instance is valid if its size is greater than, or equal to, this value.
  , forall (referencedTypes :: [*]).
MapSchema referencedTypes -> Maybe Natural
maxItems    :: Maybe Natural
  -- ^ A map instance is valid if its size is less than, or equal to, this value.
  }
  deriving stock (MapSchema referencedTypes -> MapSchema referencedTypes -> Bool
(MapSchema referencedTypes -> MapSchema referencedTypes -> Bool)
-> (MapSchema referencedTypes -> MapSchema referencedTypes -> Bool)
-> Eq (MapSchema referencedTypes)
forall (referencedTypes :: [*]).
MapSchema referencedTypes -> MapSchema referencedTypes -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall (referencedTypes :: [*]).
MapSchema referencedTypes -> MapSchema referencedTypes -> Bool
== :: MapSchema referencedTypes -> MapSchema referencedTypes -> Bool
$c/= :: forall (referencedTypes :: [*]).
MapSchema referencedTypes -> MapSchema referencedTypes -> Bool
/= :: MapSchema referencedTypes -> MapSchema referencedTypes -> Bool
Eq, Eq (MapSchema referencedTypes)
Eq (MapSchema referencedTypes) =>
(MapSchema referencedTypes
 -> MapSchema referencedTypes -> Ordering)
-> (MapSchema referencedTypes -> MapSchema referencedTypes -> Bool)
-> (MapSchema referencedTypes -> MapSchema referencedTypes -> Bool)
-> (MapSchema referencedTypes -> MapSchema referencedTypes -> Bool)
-> (MapSchema referencedTypes -> MapSchema referencedTypes -> Bool)
-> (MapSchema referencedTypes
    -> MapSchema referencedTypes -> MapSchema referencedTypes)
-> (MapSchema referencedTypes
    -> MapSchema referencedTypes -> MapSchema referencedTypes)
-> Ord (MapSchema referencedTypes)
MapSchema referencedTypes -> MapSchema referencedTypes -> Bool
MapSchema referencedTypes -> MapSchema referencedTypes -> Ordering
MapSchema referencedTypes
-> MapSchema referencedTypes -> MapSchema referencedTypes
forall (referencedTypes :: [*]). Eq (MapSchema referencedTypes)
forall (referencedTypes :: [*]).
MapSchema referencedTypes -> MapSchema referencedTypes -> Bool
forall (referencedTypes :: [*]).
MapSchema referencedTypes -> MapSchema referencedTypes -> Ordering
forall (referencedTypes :: [*]).
MapSchema referencedTypes
-> MapSchema referencedTypes -> MapSchema referencedTypes
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 :: forall (referencedTypes :: [*]).
MapSchema referencedTypes -> MapSchema referencedTypes -> Ordering
compare :: MapSchema referencedTypes -> MapSchema referencedTypes -> Ordering
$c< :: forall (referencedTypes :: [*]).
MapSchema referencedTypes -> MapSchema referencedTypes -> Bool
< :: MapSchema referencedTypes -> MapSchema referencedTypes -> Bool
$c<= :: forall (referencedTypes :: [*]).
MapSchema referencedTypes -> MapSchema referencedTypes -> Bool
<= :: MapSchema referencedTypes -> MapSchema referencedTypes -> Bool
$c> :: forall (referencedTypes :: [*]).
MapSchema referencedTypes -> MapSchema referencedTypes -> Bool
> :: MapSchema referencedTypes -> MapSchema referencedTypes -> Bool
$c>= :: forall (referencedTypes :: [*]).
MapSchema referencedTypes -> MapSchema referencedTypes -> Bool
>= :: MapSchema referencedTypes -> MapSchema referencedTypes -> Bool
$cmax :: forall (referencedTypes :: [*]).
MapSchema referencedTypes
-> MapSchema referencedTypes -> MapSchema referencedTypes
max :: MapSchema referencedTypes
-> MapSchema referencedTypes -> MapSchema referencedTypes
$cmin :: forall (referencedTypes :: [*]).
MapSchema referencedTypes
-> MapSchema referencedTypes -> MapSchema referencedTypes
min :: MapSchema referencedTypes
-> MapSchema referencedTypes -> MapSchema referencedTypes
Ord, Int -> MapSchema referencedTypes -> ShowS
[MapSchema referencedTypes] -> ShowS
MapSchema referencedTypes -> String
(Int -> MapSchema referencedTypes -> ShowS)
-> (MapSchema referencedTypes -> String)
-> ([MapSchema referencedTypes] -> ShowS)
-> Show (MapSchema referencedTypes)
forall (referencedTypes :: [*]).
Int -> MapSchema referencedTypes -> ShowS
forall (referencedTypes :: [*]).
[MapSchema referencedTypes] -> ShowS
forall (referencedTypes :: [*]).
MapSchema referencedTypes -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall (referencedTypes :: [*]).
Int -> MapSchema referencedTypes -> ShowS
showsPrec :: Int -> MapSchema referencedTypes -> ShowS
$cshow :: forall (referencedTypes :: [*]).
MapSchema referencedTypes -> String
show :: MapSchema referencedTypes -> String
$cshowList :: forall (referencedTypes :: [*]).
[MapSchema referencedTypes] -> ShowS
showList :: [MapSchema referencedTypes] -> ShowS
Show, (forall x.
 MapSchema referencedTypes -> Rep (MapSchema referencedTypes) x)
-> (forall x.
    Rep (MapSchema referencedTypes) x -> MapSchema referencedTypes)
-> Generic (MapSchema referencedTypes)
forall (referencedTypes :: [*]) x.
Rep (MapSchema referencedTypes) x -> MapSchema referencedTypes
forall (referencedTypes :: [*]) x.
MapSchema referencedTypes -> Rep (MapSchema referencedTypes) x
forall x.
Rep (MapSchema referencedTypes) x -> MapSchema referencedTypes
forall x.
MapSchema referencedTypes -> Rep (MapSchema referencedTypes) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall (referencedTypes :: [*]) x.
MapSchema referencedTypes -> Rep (MapSchema referencedTypes) x
from :: forall x.
MapSchema referencedTypes -> Rep (MapSchema referencedTypes) x
$cto :: forall (referencedTypes :: [*]) x.
Rep (MapSchema referencedTypes) x -> MapSchema referencedTypes
to :: forall x.
Rep (MapSchema referencedTypes) x -> MapSchema referencedTypes
Generic, Typeable (MapSchema referencedTypes)
Typeable (MapSchema referencedTypes) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> MapSchema referencedTypes
 -> c (MapSchema referencedTypes))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (MapSchema referencedTypes))
-> (MapSchema referencedTypes -> Constr)
-> (MapSchema referencedTypes -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d))
    -> Maybe (c (MapSchema referencedTypes)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (MapSchema referencedTypes)))
-> ((forall b. Data b => b -> b)
    -> MapSchema referencedTypes -> MapSchema referencedTypes)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> MapSchema referencedTypes
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> MapSchema referencedTypes
    -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> MapSchema referencedTypes -> [u])
-> (forall u.
    Int
    -> (forall d. Data d => d -> u) -> MapSchema referencedTypes -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> MapSchema referencedTypes -> m (MapSchema referencedTypes))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> MapSchema referencedTypes -> m (MapSchema referencedTypes))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> MapSchema referencedTypes -> m (MapSchema referencedTypes))
-> Data (MapSchema referencedTypes)
MapSchema referencedTypes -> Constr
MapSchema referencedTypes -> DataType
(forall b. Data b => b -> b)
-> MapSchema referencedTypes -> MapSchema referencedTypes
forall (referencedTypes :: [*]).
Typeable referencedTypes =>
Typeable (MapSchema referencedTypes)
forall (referencedTypes :: [*]).
Typeable referencedTypes =>
MapSchema referencedTypes -> Constr
forall (referencedTypes :: [*]).
Typeable referencedTypes =>
MapSchema referencedTypes -> DataType
forall (referencedTypes :: [*]).
Typeable referencedTypes =>
(forall b. Data b => b -> b)
-> MapSchema referencedTypes -> MapSchema referencedTypes
forall (referencedTypes :: [*]) u.
Typeable referencedTypes =>
Int
-> (forall d. Data d => d -> u) -> MapSchema referencedTypes -> u
forall (referencedTypes :: [*]) u.
Typeable referencedTypes =>
(forall d. Data d => d -> u) -> MapSchema referencedTypes -> [u]
forall (referencedTypes :: [*]) r r'.
Typeable referencedTypes =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> MapSchema referencedTypes
-> r
forall (referencedTypes :: [*]) r r'.
Typeable referencedTypes =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> MapSchema referencedTypes
-> r
forall (referencedTypes :: [*]) (m :: * -> *).
(Typeable referencedTypes, Monad m) =>
(forall d. Data d => d -> m d)
-> MapSchema referencedTypes -> m (MapSchema referencedTypes)
forall (referencedTypes :: [*]) (m :: * -> *).
(Typeable referencedTypes, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> MapSchema referencedTypes -> m (MapSchema referencedTypes)
forall (referencedTypes :: [*]) (c :: * -> *).
Typeable referencedTypes =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MapSchema referencedTypes)
forall (referencedTypes :: [*]) (c :: * -> *).
Typeable referencedTypes =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> MapSchema referencedTypes
-> c (MapSchema referencedTypes)
forall (referencedTypes :: [*]) (t :: * -> *) (c :: * -> *).
(Typeable referencedTypes, Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (MapSchema referencedTypes))
forall (referencedTypes :: [*]) (t :: * -> * -> *) (c :: * -> *).
(Typeable referencedTypes, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (MapSchema referencedTypes))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int
-> (forall d. Data d => d -> u) -> MapSchema referencedTypes -> u
forall u.
(forall d. Data d => d -> u) -> MapSchema referencedTypes -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> MapSchema referencedTypes
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> MapSchema referencedTypes
-> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MapSchema referencedTypes -> m (MapSchema referencedTypes)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MapSchema referencedTypes -> m (MapSchema referencedTypes)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MapSchema referencedTypes)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> MapSchema referencedTypes
-> c (MapSchema referencedTypes)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c (MapSchema referencedTypes))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (MapSchema referencedTypes))
$cgfoldl :: forall (referencedTypes :: [*]) (c :: * -> *).
Typeable referencedTypes =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> MapSchema referencedTypes
-> c (MapSchema referencedTypes)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> MapSchema referencedTypes
-> c (MapSchema referencedTypes)
$cgunfold :: forall (referencedTypes :: [*]) (c :: * -> *).
Typeable referencedTypes =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MapSchema referencedTypes)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MapSchema referencedTypes)
$ctoConstr :: forall (referencedTypes :: [*]).
Typeable referencedTypes =>
MapSchema referencedTypes -> Constr
toConstr :: MapSchema referencedTypes -> Constr
$cdataTypeOf :: forall (referencedTypes :: [*]).
Typeable referencedTypes =>
MapSchema referencedTypes -> DataType
dataTypeOf :: MapSchema referencedTypes -> DataType
$cdataCast1 :: forall (referencedTypes :: [*]) (t :: * -> *) (c :: * -> *).
(Typeable referencedTypes, Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (MapSchema referencedTypes))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c (MapSchema referencedTypes))
$cdataCast2 :: forall (referencedTypes :: [*]) (t :: * -> * -> *) (c :: * -> *).
(Typeable referencedTypes, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (MapSchema referencedTypes))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (MapSchema referencedTypes))
$cgmapT :: forall (referencedTypes :: [*]).
Typeable referencedTypes =>
(forall b. Data b => b -> b)
-> MapSchema referencedTypes -> MapSchema referencedTypes
gmapT :: (forall b. Data b => b -> b)
-> MapSchema referencedTypes -> MapSchema referencedTypes
$cgmapQl :: forall (referencedTypes :: [*]) r r'.
Typeable referencedTypes =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> MapSchema referencedTypes
-> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> MapSchema referencedTypes
-> r
$cgmapQr :: forall (referencedTypes :: [*]) r r'.
Typeable referencedTypes =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> MapSchema referencedTypes
-> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> MapSchema referencedTypes
-> r
$cgmapQ :: forall (referencedTypes :: [*]) u.
Typeable referencedTypes =>
(forall d. Data d => d -> u) -> MapSchema referencedTypes -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> MapSchema referencedTypes -> [u]
$cgmapQi :: forall (referencedTypes :: [*]) u.
Typeable referencedTypes =>
Int
-> (forall d. Data d => d -> u) -> MapSchema referencedTypes -> u
gmapQi :: forall u.
Int
-> (forall d. Data d => d -> u) -> MapSchema referencedTypes -> u
$cgmapM :: forall (referencedTypes :: [*]) (m :: * -> *).
(Typeable referencedTypes, Monad m) =>
(forall d. Data d => d -> m d)
-> MapSchema referencedTypes -> m (MapSchema referencedTypes)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> MapSchema referencedTypes -> m (MapSchema referencedTypes)
$cgmapMp :: forall (referencedTypes :: [*]) (m :: * -> *).
(Typeable referencedTypes, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> MapSchema referencedTypes -> m (MapSchema referencedTypes)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MapSchema referencedTypes -> m (MapSchema referencedTypes)
$cgmapMo :: forall (referencedTypes :: [*]) (m :: * -> *).
(Typeable referencedTypes, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> MapSchema referencedTypes -> m (MapSchema referencedTypes)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> MapSchema referencedTypes -> m (MapSchema referencedTypes)
Data)

data ConstructorSchema (referencedTypes :: [Type]) = MkConstructorSchema
  { forall (referencedTypes :: [*]).
ConstructorSchema referencedTypes -> Natural
index        :: Natural
  -- ^ Constructor index
  , forall (referencedTypes :: [*]).
ConstructorSchema referencedTypes -> [Schema referencedTypes]
fieldSchemas :: [Schema referencedTypes]
  -- ^ Field schemas
  }
  deriving stock (ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes -> Bool
(ConstructorSchema referencedTypes
 -> ConstructorSchema referencedTypes -> Bool)
-> (ConstructorSchema referencedTypes
    -> ConstructorSchema referencedTypes -> Bool)
-> Eq (ConstructorSchema referencedTypes)
forall (referencedTypes :: [*]).
ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall (referencedTypes :: [*]).
ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes -> Bool
== :: ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes -> Bool
$c/= :: forall (referencedTypes :: [*]).
ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes -> Bool
/= :: ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes -> Bool
Eq, Eq (ConstructorSchema referencedTypes)
Eq (ConstructorSchema referencedTypes) =>
(ConstructorSchema referencedTypes
 -> ConstructorSchema referencedTypes -> Ordering)
-> (ConstructorSchema referencedTypes
    -> ConstructorSchema referencedTypes -> Bool)
-> (ConstructorSchema referencedTypes
    -> ConstructorSchema referencedTypes -> Bool)
-> (ConstructorSchema referencedTypes
    -> ConstructorSchema referencedTypes -> Bool)
-> (ConstructorSchema referencedTypes
    -> ConstructorSchema referencedTypes -> Bool)
-> (ConstructorSchema referencedTypes
    -> ConstructorSchema referencedTypes
    -> ConstructorSchema referencedTypes)
-> (ConstructorSchema referencedTypes
    -> ConstructorSchema referencedTypes
    -> ConstructorSchema referencedTypes)
-> Ord (ConstructorSchema referencedTypes)
ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes -> Bool
ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes -> Ordering
ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes
forall (referencedTypes :: [*]).
Eq (ConstructorSchema referencedTypes)
forall (referencedTypes :: [*]).
ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes -> Bool
forall (referencedTypes :: [*]).
ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes -> Ordering
forall (referencedTypes :: [*]).
ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes
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 :: forall (referencedTypes :: [*]).
ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes -> Ordering
compare :: ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes -> Ordering
$c< :: forall (referencedTypes :: [*]).
ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes -> Bool
< :: ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes -> Bool
$c<= :: forall (referencedTypes :: [*]).
ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes -> Bool
<= :: ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes -> Bool
$c> :: forall (referencedTypes :: [*]).
ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes -> Bool
> :: ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes -> Bool
$c>= :: forall (referencedTypes :: [*]).
ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes -> Bool
>= :: ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes -> Bool
$cmax :: forall (referencedTypes :: [*]).
ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes
max :: ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes
$cmin :: forall (referencedTypes :: [*]).
ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes
min :: ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes
Ord, Int -> ConstructorSchema referencedTypes -> ShowS
[ConstructorSchema referencedTypes] -> ShowS
ConstructorSchema referencedTypes -> String
(Int -> ConstructorSchema referencedTypes -> ShowS)
-> (ConstructorSchema referencedTypes -> String)
-> ([ConstructorSchema referencedTypes] -> ShowS)
-> Show (ConstructorSchema referencedTypes)
forall (referencedTypes :: [*]).
Int -> ConstructorSchema referencedTypes -> ShowS
forall (referencedTypes :: [*]).
[ConstructorSchema referencedTypes] -> ShowS
forall (referencedTypes :: [*]).
ConstructorSchema referencedTypes -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall (referencedTypes :: [*]).
Int -> ConstructorSchema referencedTypes -> ShowS
showsPrec :: Int -> ConstructorSchema referencedTypes -> ShowS
$cshow :: forall (referencedTypes :: [*]).
ConstructorSchema referencedTypes -> String
show :: ConstructorSchema referencedTypes -> String
$cshowList :: forall (referencedTypes :: [*]).
[ConstructorSchema referencedTypes] -> ShowS
showList :: [ConstructorSchema referencedTypes] -> ShowS
Show, (forall x.
 ConstructorSchema referencedTypes
 -> Rep (ConstructorSchema referencedTypes) x)
-> (forall x.
    Rep (ConstructorSchema referencedTypes) x
    -> ConstructorSchema referencedTypes)
-> Generic (ConstructorSchema referencedTypes)
forall (referencedTypes :: [*]) x.
Rep (ConstructorSchema referencedTypes) x
-> ConstructorSchema referencedTypes
forall (referencedTypes :: [*]) x.
ConstructorSchema referencedTypes
-> Rep (ConstructorSchema referencedTypes) x
forall x.
Rep (ConstructorSchema referencedTypes) x
-> ConstructorSchema referencedTypes
forall x.
ConstructorSchema referencedTypes
-> Rep (ConstructorSchema referencedTypes) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall (referencedTypes :: [*]) x.
ConstructorSchema referencedTypes
-> Rep (ConstructorSchema referencedTypes) x
from :: forall x.
ConstructorSchema referencedTypes
-> Rep (ConstructorSchema referencedTypes) x
$cto :: forall (referencedTypes :: [*]) x.
Rep (ConstructorSchema referencedTypes) x
-> ConstructorSchema referencedTypes
to :: forall x.
Rep (ConstructorSchema referencedTypes) x
-> ConstructorSchema referencedTypes
Generic, Typeable (ConstructorSchema referencedTypes)
Typeable (ConstructorSchema referencedTypes) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> ConstructorSchema referencedTypes
 -> c (ConstructorSchema referencedTypes))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r)
    -> Constr
    -> c (ConstructorSchema referencedTypes))
-> (ConstructorSchema referencedTypes -> Constr)
-> (ConstructorSchema referencedTypes -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d))
    -> Maybe (c (ConstructorSchema referencedTypes)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ConstructorSchema referencedTypes)))
-> ((forall b. Data b => b -> b)
    -> ConstructorSchema referencedTypes
    -> ConstructorSchema referencedTypes)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> ConstructorSchema referencedTypes
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> ConstructorSchema referencedTypes
    -> r)
-> (forall u.
    (forall d. Data d => d -> u)
    -> ConstructorSchema referencedTypes -> [u])
-> (forall u.
    Int
    -> (forall d. Data d => d -> u)
    -> ConstructorSchema referencedTypes
    -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ConstructorSchema referencedTypes
    -> m (ConstructorSchema referencedTypes))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ConstructorSchema referencedTypes
    -> m (ConstructorSchema referencedTypes))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ConstructorSchema referencedTypes
    -> m (ConstructorSchema referencedTypes))
-> Data (ConstructorSchema referencedTypes)
ConstructorSchema referencedTypes -> Constr
ConstructorSchema referencedTypes -> DataType
(forall b. Data b => b -> b)
-> ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes
forall (referencedTypes :: [*]).
Typeable referencedTypes =>
Typeable (ConstructorSchema referencedTypes)
forall (referencedTypes :: [*]).
Typeable referencedTypes =>
ConstructorSchema referencedTypes -> Constr
forall (referencedTypes :: [*]).
Typeable referencedTypes =>
ConstructorSchema referencedTypes -> DataType
forall (referencedTypes :: [*]).
Typeable referencedTypes =>
(forall b. Data b => b -> b)
-> ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes
forall (referencedTypes :: [*]) u.
Typeable referencedTypes =>
Int
-> (forall d. Data d => d -> u)
-> ConstructorSchema referencedTypes
-> u
forall (referencedTypes :: [*]) u.
Typeable referencedTypes =>
(forall d. Data d => d -> u)
-> ConstructorSchema referencedTypes -> [u]
forall (referencedTypes :: [*]) r r'.
Typeable referencedTypes =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> ConstructorSchema referencedTypes
-> r
forall (referencedTypes :: [*]) r r'.
Typeable referencedTypes =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> ConstructorSchema referencedTypes
-> r
forall (referencedTypes :: [*]) (m :: * -> *).
(Typeable referencedTypes, Monad m) =>
(forall d. Data d => d -> m d)
-> ConstructorSchema referencedTypes
-> m (ConstructorSchema referencedTypes)
forall (referencedTypes :: [*]) (m :: * -> *).
(Typeable referencedTypes, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ConstructorSchema referencedTypes
-> m (ConstructorSchema referencedTypes)
forall (referencedTypes :: [*]) (c :: * -> *).
Typeable referencedTypes =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (ConstructorSchema referencedTypes)
forall (referencedTypes :: [*]) (c :: * -> *).
Typeable referencedTypes =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ConstructorSchema referencedTypes
-> c (ConstructorSchema referencedTypes)
forall (referencedTypes :: [*]) (t :: * -> *) (c :: * -> *).
(Typeable referencedTypes, Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (ConstructorSchema referencedTypes))
forall (referencedTypes :: [*]) (t :: * -> * -> *) (c :: * -> *).
(Typeable referencedTypes, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ConstructorSchema referencedTypes))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int
-> (forall d. Data d => d -> u)
-> ConstructorSchema referencedTypes
-> u
forall u.
(forall d. Data d => d -> u)
-> ConstructorSchema referencedTypes -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> ConstructorSchema referencedTypes
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> ConstructorSchema referencedTypes
-> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ConstructorSchema referencedTypes
-> m (ConstructorSchema referencedTypes)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ConstructorSchema referencedTypes
-> m (ConstructorSchema referencedTypes)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (ConstructorSchema referencedTypes)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ConstructorSchema referencedTypes
-> c (ConstructorSchema referencedTypes)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c (ConstructorSchema referencedTypes))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ConstructorSchema referencedTypes))
$cgfoldl :: forall (referencedTypes :: [*]) (c :: * -> *).
Typeable referencedTypes =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ConstructorSchema referencedTypes
-> c (ConstructorSchema referencedTypes)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ConstructorSchema referencedTypes
-> c (ConstructorSchema referencedTypes)
$cgunfold :: forall (referencedTypes :: [*]) (c :: * -> *).
Typeable referencedTypes =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (ConstructorSchema referencedTypes)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (ConstructorSchema referencedTypes)
$ctoConstr :: forall (referencedTypes :: [*]).
Typeable referencedTypes =>
ConstructorSchema referencedTypes -> Constr
toConstr :: ConstructorSchema referencedTypes -> Constr
$cdataTypeOf :: forall (referencedTypes :: [*]).
Typeable referencedTypes =>
ConstructorSchema referencedTypes -> DataType
dataTypeOf :: ConstructorSchema referencedTypes -> DataType
$cdataCast1 :: forall (referencedTypes :: [*]) (t :: * -> *) (c :: * -> *).
(Typeable referencedTypes, Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (ConstructorSchema referencedTypes))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c (ConstructorSchema referencedTypes))
$cdataCast2 :: forall (referencedTypes :: [*]) (t :: * -> * -> *) (c :: * -> *).
(Typeable referencedTypes, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ConstructorSchema referencedTypes))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ConstructorSchema referencedTypes))
$cgmapT :: forall (referencedTypes :: [*]).
Typeable referencedTypes =>
(forall b. Data b => b -> b)
-> ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes
gmapT :: (forall b. Data b => b -> b)
-> ConstructorSchema referencedTypes
-> ConstructorSchema referencedTypes
$cgmapQl :: forall (referencedTypes :: [*]) r r'.
Typeable referencedTypes =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> ConstructorSchema referencedTypes
-> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> ConstructorSchema referencedTypes
-> r
$cgmapQr :: forall (referencedTypes :: [*]) r r'.
Typeable referencedTypes =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> ConstructorSchema referencedTypes
-> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> ConstructorSchema referencedTypes
-> r
$cgmapQ :: forall (referencedTypes :: [*]) u.
Typeable referencedTypes =>
(forall d. Data d => d -> u)
-> ConstructorSchema referencedTypes -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u)
-> ConstructorSchema referencedTypes -> [u]
$cgmapQi :: forall (referencedTypes :: [*]) u.
Typeable referencedTypes =>
Int
-> (forall d. Data d => d -> u)
-> ConstructorSchema referencedTypes
-> u
gmapQi :: forall u.
Int
-> (forall d. Data d => d -> u)
-> ConstructorSchema referencedTypes
-> u
$cgmapM :: forall (referencedTypes :: [*]) (m :: * -> *).
(Typeable referencedTypes, Monad m) =>
(forall d. Data d => d -> m d)
-> ConstructorSchema referencedTypes
-> m (ConstructorSchema referencedTypes)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ConstructorSchema referencedTypes
-> m (ConstructorSchema referencedTypes)
$cgmapMp :: forall (referencedTypes :: [*]) (m :: * -> *).
(Typeable referencedTypes, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ConstructorSchema referencedTypes
-> m (ConstructorSchema referencedTypes)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ConstructorSchema referencedTypes
-> m (ConstructorSchema referencedTypes)
$cgmapMo :: forall (referencedTypes :: [*]) (m :: * -> *).
(Typeable referencedTypes, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ConstructorSchema referencedTypes
-> m (ConstructorSchema referencedTypes)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ConstructorSchema referencedTypes
-> m (ConstructorSchema referencedTypes)
Data)

data PairSchema (referencedTypes :: [Type]) = MkPairSchema
  { forall (referencedTypes :: [*]).
PairSchema referencedTypes -> Schema referencedTypes
left  :: Schema referencedTypes
  -- ^ Schema of the first element
  , forall (referencedTypes :: [*]).
PairSchema referencedTypes -> Schema referencedTypes
right :: Schema referencedTypes
  -- ^ Schema of the second element
  }
  deriving stock (PairSchema referencedTypes -> PairSchema referencedTypes -> Bool
(PairSchema referencedTypes -> PairSchema referencedTypes -> Bool)
-> (PairSchema referencedTypes
    -> PairSchema referencedTypes -> Bool)
-> Eq (PairSchema referencedTypes)
forall (referencedTypes :: [*]).
PairSchema referencedTypes -> PairSchema referencedTypes -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall (referencedTypes :: [*]).
PairSchema referencedTypes -> PairSchema referencedTypes -> Bool
== :: PairSchema referencedTypes -> PairSchema referencedTypes -> Bool
$c/= :: forall (referencedTypes :: [*]).
PairSchema referencedTypes -> PairSchema referencedTypes -> Bool
/= :: PairSchema referencedTypes -> PairSchema referencedTypes -> Bool
Eq, Eq (PairSchema referencedTypes)
Eq (PairSchema referencedTypes) =>
(PairSchema referencedTypes
 -> PairSchema referencedTypes -> Ordering)
-> (PairSchema referencedTypes
    -> PairSchema referencedTypes -> Bool)
-> (PairSchema referencedTypes
    -> PairSchema referencedTypes -> Bool)
-> (PairSchema referencedTypes
    -> PairSchema referencedTypes -> Bool)
-> (PairSchema referencedTypes
    -> PairSchema referencedTypes -> Bool)
-> (PairSchema referencedTypes
    -> PairSchema referencedTypes -> PairSchema referencedTypes)
-> (PairSchema referencedTypes
    -> PairSchema referencedTypes -> PairSchema referencedTypes)
-> Ord (PairSchema referencedTypes)
PairSchema referencedTypes -> PairSchema referencedTypes -> Bool
PairSchema referencedTypes
-> PairSchema referencedTypes -> Ordering
PairSchema referencedTypes
-> PairSchema referencedTypes -> PairSchema referencedTypes
forall (referencedTypes :: [*]). Eq (PairSchema referencedTypes)
forall (referencedTypes :: [*]).
PairSchema referencedTypes -> PairSchema referencedTypes -> Bool
forall (referencedTypes :: [*]).
PairSchema referencedTypes
-> PairSchema referencedTypes -> Ordering
forall (referencedTypes :: [*]).
PairSchema referencedTypes
-> PairSchema referencedTypes -> PairSchema referencedTypes
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 :: forall (referencedTypes :: [*]).
PairSchema referencedTypes
-> PairSchema referencedTypes -> Ordering
compare :: PairSchema referencedTypes
-> PairSchema referencedTypes -> Ordering
$c< :: forall (referencedTypes :: [*]).
PairSchema referencedTypes -> PairSchema referencedTypes -> Bool
< :: PairSchema referencedTypes -> PairSchema referencedTypes -> Bool
$c<= :: forall (referencedTypes :: [*]).
PairSchema referencedTypes -> PairSchema referencedTypes -> Bool
<= :: PairSchema referencedTypes -> PairSchema referencedTypes -> Bool
$c> :: forall (referencedTypes :: [*]).
PairSchema referencedTypes -> PairSchema referencedTypes -> Bool
> :: PairSchema referencedTypes -> PairSchema referencedTypes -> Bool
$c>= :: forall (referencedTypes :: [*]).
PairSchema referencedTypes -> PairSchema referencedTypes -> Bool
>= :: PairSchema referencedTypes -> PairSchema referencedTypes -> Bool
$cmax :: forall (referencedTypes :: [*]).
PairSchema referencedTypes
-> PairSchema referencedTypes -> PairSchema referencedTypes
max :: PairSchema referencedTypes
-> PairSchema referencedTypes -> PairSchema referencedTypes
$cmin :: forall (referencedTypes :: [*]).
PairSchema referencedTypes
-> PairSchema referencedTypes -> PairSchema referencedTypes
min :: PairSchema referencedTypes
-> PairSchema referencedTypes -> PairSchema referencedTypes
Ord, Int -> PairSchema referencedTypes -> ShowS
[PairSchema referencedTypes] -> ShowS
PairSchema referencedTypes -> String
(Int -> PairSchema referencedTypes -> ShowS)
-> (PairSchema referencedTypes -> String)
-> ([PairSchema referencedTypes] -> ShowS)
-> Show (PairSchema referencedTypes)
forall (referencedTypes :: [*]).
Int -> PairSchema referencedTypes -> ShowS
forall (referencedTypes :: [*]).
[PairSchema referencedTypes] -> ShowS
forall (referencedTypes :: [*]).
PairSchema referencedTypes -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall (referencedTypes :: [*]).
Int -> PairSchema referencedTypes -> ShowS
showsPrec :: Int -> PairSchema referencedTypes -> ShowS
$cshow :: forall (referencedTypes :: [*]).
PairSchema referencedTypes -> String
show :: PairSchema referencedTypes -> String
$cshowList :: forall (referencedTypes :: [*]).
[PairSchema referencedTypes] -> ShowS
showList :: [PairSchema referencedTypes] -> ShowS
Show, (forall x.
 PairSchema referencedTypes -> Rep (PairSchema referencedTypes) x)
-> (forall x.
    Rep (PairSchema referencedTypes) x -> PairSchema referencedTypes)
-> Generic (PairSchema referencedTypes)
forall (referencedTypes :: [*]) x.
Rep (PairSchema referencedTypes) x -> PairSchema referencedTypes
forall (referencedTypes :: [*]) x.
PairSchema referencedTypes -> Rep (PairSchema referencedTypes) x
forall x.
Rep (PairSchema referencedTypes) x -> PairSchema referencedTypes
forall x.
PairSchema referencedTypes -> Rep (PairSchema referencedTypes) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall (referencedTypes :: [*]) x.
PairSchema referencedTypes -> Rep (PairSchema referencedTypes) x
from :: forall x.
PairSchema referencedTypes -> Rep (PairSchema referencedTypes) x
$cto :: forall (referencedTypes :: [*]) x.
Rep (PairSchema referencedTypes) x -> PairSchema referencedTypes
to :: forall x.
Rep (PairSchema referencedTypes) x -> PairSchema referencedTypes
Generic, Typeable (PairSchema referencedTypes)
Typeable (PairSchema referencedTypes) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> PairSchema referencedTypes
 -> c (PairSchema referencedTypes))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r)
    -> Constr
    -> c (PairSchema referencedTypes))
-> (PairSchema referencedTypes -> Constr)
-> (PairSchema referencedTypes -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d))
    -> Maybe (c (PairSchema referencedTypes)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (PairSchema referencedTypes)))
-> ((forall b. Data b => b -> b)
    -> PairSchema referencedTypes -> PairSchema referencedTypes)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> PairSchema referencedTypes
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> PairSchema referencedTypes
    -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> PairSchema referencedTypes -> [u])
-> (forall u.
    Int
    -> (forall d. Data d => d -> u) -> PairSchema referencedTypes -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> PairSchema referencedTypes -> m (PairSchema referencedTypes))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PairSchema referencedTypes -> m (PairSchema referencedTypes))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PairSchema referencedTypes -> m (PairSchema referencedTypes))
-> Data (PairSchema referencedTypes)
PairSchema referencedTypes -> Constr
PairSchema referencedTypes -> DataType
(forall b. Data b => b -> b)
-> PairSchema referencedTypes -> PairSchema referencedTypes
forall (referencedTypes :: [*]).
Typeable referencedTypes =>
Typeable (PairSchema referencedTypes)
forall (referencedTypes :: [*]).
Typeable referencedTypes =>
PairSchema referencedTypes -> Constr
forall (referencedTypes :: [*]).
Typeable referencedTypes =>
PairSchema referencedTypes -> DataType
forall (referencedTypes :: [*]).
Typeable referencedTypes =>
(forall b. Data b => b -> b)
-> PairSchema referencedTypes -> PairSchema referencedTypes
forall (referencedTypes :: [*]) u.
Typeable referencedTypes =>
Int
-> (forall d. Data d => d -> u) -> PairSchema referencedTypes -> u
forall (referencedTypes :: [*]) u.
Typeable referencedTypes =>
(forall d. Data d => d -> u) -> PairSchema referencedTypes -> [u]
forall (referencedTypes :: [*]) r r'.
Typeable referencedTypes =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> PairSchema referencedTypes
-> r
forall (referencedTypes :: [*]) r r'.
Typeable referencedTypes =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> PairSchema referencedTypes
-> r
forall (referencedTypes :: [*]) (m :: * -> *).
(Typeable referencedTypes, Monad m) =>
(forall d. Data d => d -> m d)
-> PairSchema referencedTypes -> m (PairSchema referencedTypes)
forall (referencedTypes :: [*]) (m :: * -> *).
(Typeable referencedTypes, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> PairSchema referencedTypes -> m (PairSchema referencedTypes)
forall (referencedTypes :: [*]) (c :: * -> *).
Typeable referencedTypes =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PairSchema referencedTypes)
forall (referencedTypes :: [*]) (c :: * -> *).
Typeable referencedTypes =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> PairSchema referencedTypes
-> c (PairSchema referencedTypes)
forall (referencedTypes :: [*]) (t :: * -> *) (c :: * -> *).
(Typeable referencedTypes, Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (PairSchema referencedTypes))
forall (referencedTypes :: [*]) (t :: * -> * -> *) (c :: * -> *).
(Typeable referencedTypes, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PairSchema referencedTypes))
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int
-> (forall d. Data d => d -> u) -> PairSchema referencedTypes -> u
forall u.
(forall d. Data d => d -> u) -> PairSchema referencedTypes -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> PairSchema referencedTypes
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> PairSchema referencedTypes
-> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PairSchema referencedTypes -> m (PairSchema referencedTypes)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PairSchema referencedTypes -> m (PairSchema referencedTypes)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PairSchema referencedTypes)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> PairSchema referencedTypes
-> c (PairSchema referencedTypes)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c (PairSchema referencedTypes))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PairSchema referencedTypes))
$cgfoldl :: forall (referencedTypes :: [*]) (c :: * -> *).
Typeable referencedTypes =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> PairSchema referencedTypes
-> c (PairSchema referencedTypes)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> PairSchema referencedTypes
-> c (PairSchema referencedTypes)
$cgunfold :: forall (referencedTypes :: [*]) (c :: * -> *).
Typeable referencedTypes =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PairSchema referencedTypes)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PairSchema referencedTypes)
$ctoConstr :: forall (referencedTypes :: [*]).
Typeable referencedTypes =>
PairSchema referencedTypes -> Constr
toConstr :: PairSchema referencedTypes -> Constr
$cdataTypeOf :: forall (referencedTypes :: [*]).
Typeable referencedTypes =>
PairSchema referencedTypes -> DataType
dataTypeOf :: PairSchema referencedTypes -> DataType
$cdataCast1 :: forall (referencedTypes :: [*]) (t :: * -> *) (c :: * -> *).
(Typeable referencedTypes, Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (PairSchema referencedTypes))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c (PairSchema referencedTypes))
$cdataCast2 :: forall (referencedTypes :: [*]) (t :: * -> * -> *) (c :: * -> *).
(Typeable referencedTypes, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PairSchema referencedTypes))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (PairSchema referencedTypes))
$cgmapT :: forall (referencedTypes :: [*]).
Typeable referencedTypes =>
(forall b. Data b => b -> b)
-> PairSchema referencedTypes -> PairSchema referencedTypes
gmapT :: (forall b. Data b => b -> b)
-> PairSchema referencedTypes -> PairSchema referencedTypes
$cgmapQl :: forall (referencedTypes :: [*]) r r'.
Typeable referencedTypes =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> PairSchema referencedTypes
-> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> PairSchema referencedTypes
-> r
$cgmapQr :: forall (referencedTypes :: [*]) r r'.
Typeable referencedTypes =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> PairSchema referencedTypes
-> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> PairSchema referencedTypes
-> r
$cgmapQ :: forall (referencedTypes :: [*]) u.
Typeable referencedTypes =>
(forall d. Data d => d -> u) -> PairSchema referencedTypes -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> PairSchema referencedTypes -> [u]
$cgmapQi :: forall (referencedTypes :: [*]) u.
Typeable referencedTypes =>
Int
-> (forall d. Data d => d -> u) -> PairSchema referencedTypes -> u
gmapQi :: forall u.
Int
-> (forall d. Data d => d -> u) -> PairSchema referencedTypes -> u
$cgmapM :: forall (referencedTypes :: [*]) (m :: * -> *).
(Typeable referencedTypes, Monad m) =>
(forall d. Data d => d -> m d)
-> PairSchema referencedTypes -> m (PairSchema referencedTypes)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PairSchema referencedTypes -> m (PairSchema referencedTypes)
$cgmapMp :: forall (referencedTypes :: [*]) (m :: * -> *).
(Typeable referencedTypes, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> PairSchema referencedTypes -> m (PairSchema referencedTypes)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PairSchema referencedTypes -> m (PairSchema referencedTypes)
$cgmapMo :: forall (referencedTypes :: [*]) (m :: * -> *).
(Typeable referencedTypes, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> PairSchema referencedTypes -> m (PairSchema referencedTypes)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PairSchema referencedTypes -> m (PairSchema referencedTypes)
Data)