Pdl.hs

-- Note: this is an automatically generated file. Do not edit.

-- | A model for PDL (Pegasus Data Language) schemas. Based on the specification at:
-- |   https://linkedin.github.io/rest.li/pdl_schema

module Hydra.Pegasus.Pdl where

import qualified Hydra.Core as Core
import qualified Hydra.Json.Model as Model
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
import qualified Data.Scientific as Sci

-- | Annotations which can be applied to record fields, aliased union members, enum symbols, or named schemas
data Annotations =
  Annotations {
    annotationsDoc :: (Maybe String),
    annotationsDeprecated :: Bool}
  deriving (Eq, Ord, Read, Show)

_Annotations = Core.Name "hydra.pegasus.pdl.Annotations"

_Annotations_doc = Core.Name "doc"

_Annotations_deprecated = Core.Name "deprecated"

-- | A single symbol of a PDL enum schema, with its optional annotations
data EnumField =
  EnumField {
    enumFieldName :: EnumFieldName,
    enumFieldAnnotations :: Annotations}
  deriving (Eq, Ord, Read, Show)

_EnumField = Core.Name "hydra.pegasus.pdl.EnumField"

_EnumField_name = Core.Name "name"

_EnumField_annotations = Core.Name "annotations"

-- | The name of a PDL enum symbol, conventionally in upper snake case
newtype EnumFieldName =
  EnumFieldName {
    unEnumFieldName :: String}
  deriving (Eq, Ord, Read, Show)

_EnumFieldName = Core.Name "hydra.pegasus.pdl.EnumFieldName"

-- | A PDL enum schema, defined as a fixed set of enumerated symbols
data EnumSchema =
  EnumSchema {
    enumSchemaFields :: [EnumField]}
  deriving (Eq, Ord, Read, Show)

_EnumSchema = Core.Name "hydra.pegasus.pdl.EnumSchema"

_EnumSchema_fields = Core.Name "fields"

-- | The name of a record field or an aliased union member
newtype FieldName =
  FieldName {
    unFieldName :: String}
  deriving (Eq, Ord, Read, Show)

_FieldName = Core.Name "hydra.pegasus.pdl.FieldName"

-- | The unqualified (non-namespaced) name of a PDL named schema
newtype Name =
  Name {
    unName :: String}
  deriving (Eq, Ord, Read, Show)

_Name = Core.Name "hydra.pegasus.pdl.Name"

-- | A PDL schema that has a qualified name: a record, enum, or typeref
data NamedSchema =
  NamedSchema {
    namedSchemaQualifiedName :: QualifiedName,
    namedSchemaType :: NamedSchemaType,
    namedSchemaAnnotations :: Annotations}
  deriving (Eq, Ord, Read, Show)

_NamedSchema = Core.Name "hydra.pegasus.pdl.NamedSchema"

_NamedSchema_qualifiedName = Core.Name "qualifiedName"

_NamedSchema_type = Core.Name "type"

_NamedSchema_annotations = Core.Name "annotations"

-- | The variety of a PDL named schema: record, enum, or typeref
data NamedSchemaType =
  NamedSchemaTypeRecord RecordSchema |
  NamedSchemaTypeEnum EnumSchema |
  NamedSchemaTypeTyperef Schema
  deriving (Eq, Ord, Read, Show)

_NamedSchemaType = Core.Name "hydra.pegasus.pdl.NamedSchemaType"

_NamedSchemaType_record = Core.Name "record"

_NamedSchemaType_enum = Core.Name "enum"

_NamedSchemaType_typeref = Core.Name "typeref"

-- | A dot-separated PDL namespace, analogous to a Java package name
newtype Namespace =
  Namespace {
    unNamespace :: String}
  deriving (Eq, Ord, Read, Show)

_Namespace = Core.Name "hydra.pegasus.pdl.Namespace"

-- | The Java package under which generated bindings for a schema file are placed
newtype Package =
  Package {
    unPackage :: String}
  deriving (Eq, Ord, Read, Show)

_Package = Core.Name "hydra.pegasus.pdl.Package"

-- | One of the built-in PDL primitive types
data PrimitiveType =
  PrimitiveTypeBoolean |
  PrimitiveTypeBytes |
  PrimitiveTypeDouble |
  PrimitiveTypeFloat |
  PrimitiveTypeInt |
  PrimitiveTypeLong |
  PrimitiveTypeString
  deriving (Eq, Ord, Read, Show)

_PrimitiveType = Core.Name "hydra.pegasus.pdl.PrimitiveType"

_PrimitiveType_boolean = Core.Name "boolean"

_PrimitiveType_bytes = Core.Name "bytes"

_PrimitiveType_double = Core.Name "double"

_PrimitiveType_float = Core.Name "float"

_PrimitiveType_int = Core.Name "int"

_PrimitiveType_long = Core.Name "long"

_PrimitiveType_string = Core.Name "string"

-- | A custom key/value property attached to a PDL schema, field, or member
data Property =
  Property {
    propertyKey :: PropertyKey,
    propertyValue :: (Maybe Model.Value)}
  deriving (Eq, Ord, Read, Show)

_Property = Core.Name "hydra.pegasus.pdl.Property"

_Property_key = Core.Name "key"

_Property_value = Core.Name "value"

-- | The key of a custom PDL schema property, e.g. a dot-separated path
newtype PropertyKey =
  PropertyKey {
    unPropertyKey :: String}
  deriving (Eq, Ord, Read, Show)

_PropertyKey = Core.Name "hydra.pegasus.pdl.PropertyKey"

-- | A PDL name together with the optional namespace that qualifies it
data QualifiedName =
  QualifiedName {
    qualifiedNameName :: Name,
    qualifiedNameNamespace :: (Maybe Namespace)}
  deriving (Eq, Ord, Read, Show)

_QualifiedName = Core.Name "hydra.pegasus.pdl.QualifiedName"

_QualifiedName_name = Core.Name "name"

_QualifiedName_namespace = Core.Name "namespace"

-- | Note: the default value for an enum-valued must be one of the enumerated string symbols
data RecordField =
  RecordField {
    recordFieldName :: FieldName,
    recordFieldValue :: Schema,
    recordFieldOptional :: Bool,
    recordFieldDefault :: (Maybe Model.Value),
    recordFieldAnnotations :: Annotations}
  deriving (Eq, Ord, Read, Show)

_RecordField = Core.Name "hydra.pegasus.pdl.RecordField"

_RecordField_name = Core.Name "name"

_RecordField_value = Core.Name "value"

_RecordField_optional = Core.Name "optional"

_RecordField_default = Core.Name "default"

_RecordField_annotations = Core.Name "annotations"

-- | Note: all included schemas must be record schemas
data RecordSchema =
  RecordSchema {
    recordSchemaFields :: [RecordField],
    recordSchemaIncludes :: [NamedSchema]}
  deriving (Eq, Ord, Read, Show)

_RecordSchema = Core.Name "hydra.pegasus.pdl.RecordSchema"

_RecordSchema_fields = Core.Name "fields"

_RecordSchema_includes = Core.Name "includes"

-- | A PDL data schema: either a primitive, a reference by name, or a complex type
data Schema =
  SchemaArray Schema |
  SchemaFixed Int |
  SchemaInline NamedSchema |
  SchemaMap Schema |
  SchemaNamed QualifiedName |
  SchemaNull |
  SchemaPrimitive PrimitiveType |
  SchemaUnion UnionSchema
  deriving (Eq, Ord, Read, Show)

_Schema = Core.Name "hydra.pegasus.pdl.Schema"

_Schema_array = Core.Name "array"

_Schema_fixed = Core.Name "fixed"

_Schema_inline = Core.Name "inline"

_Schema_map = Core.Name "map"

_Schema_named = Core.Name "named"

_Schema_null = Core.Name "null"

_Schema_primitive = Core.Name "primitive"

_Schema_union = Core.Name "union"

-- | A .pdl source file: a namespace declaration, imports, and one or more named schemas
data SchemaFile =
  SchemaFile {
    schemaFileNamespace :: Namespace,
    schemaFilePackage :: (Maybe Package),
    schemaFileImports :: [QualifiedName],
    schemaFileSchemas :: [NamedSchema]}
  deriving (Eq, Ord, Read, Show)

_SchemaFile = Core.Name "hydra.pegasus.pdl.SchemaFile"

_SchemaFile_namespace = Core.Name "namespace"

_SchemaFile_package = Core.Name "package"

_SchemaFile_imports = Core.Name "imports"

_SchemaFile_schemas = Core.Name "schemas"

-- | Note: annotations are only available for aliased members
data UnionMember =
  UnionMember {
    unionMemberAlias :: (Maybe FieldName),
    unionMemberValue :: Schema,
    unionMemberAnnotations :: Annotations}
  deriving (Eq, Ord, Read, Show)

_UnionMember = Core.Name "hydra.pegasus.pdl.UnionMember"

_UnionMember_alias = Core.Name "alias"

_UnionMember_value = Core.Name "value"

_UnionMember_annotations = Core.Name "annotations"

-- | Note: unions are not allowed as member types of other unions
newtype UnionSchema =
  UnionSchema {
    unUnionSchema :: [UnionMember]}
  deriving (Eq, Ord, Read, Show)

_UnionSchema = Core.Name "hydra.pegasus.pdl.UnionSchema"