hydra-0.15.0: src/main/haskell/Hydra/Shex/Syntax.hs

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

-- | A Shex model. Based on the BNF at:
-- |   https://github.com/shexSpec/grammar/blob/master/bnf

module Hydra.Shex.Syntax where

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

data ShexDoc =
  ShexDoc {
    shexDocListOfDirective :: [Directive],
    shexDocSequence :: (Maybe ShexDoc_Sequence_Option),
    shexDocPrefixDecl :: PrefixDecl}
  deriving (Eq, Ord, Read, Show)

_ShexDoc = Core.Name "hydra.shex.syntax.ShexDoc"

_ShexDoc_listOfDirective = Core.Name "listOfDirective"

_ShexDoc_Sequence = Core.Name "Sequence"

_ShexDoc_PrefixDecl = Core.Name "PrefixDecl"

data ShexDoc_Sequence_Option =
  ShexDoc_Sequence_Option {
    shexDoc_Sequence_OptionAlts :: ShexDoc_Sequence_Option_Alts,
    shexDoc_Sequence_OptionListOfStatement :: [Statement]}
  deriving (Eq, Ord, Read, Show)

_ShexDoc_Sequence_Option = Core.Name "hydra.shex.syntax.ShexDoc_Sequence_Option"

_ShexDoc_Sequence_Option_alts = Core.Name "alts"

_ShexDoc_Sequence_Option_listOfStatement = Core.Name "listOfStatement"

data ShexDoc_Sequence_Option_Alts =
  ShexDoc_Sequence_Option_AltsNotStartAction NotStartAction |
  ShexDoc_Sequence_Option_AltsStartActions StartActions
  deriving (Eq, Ord, Read, Show)

_ShexDoc_Sequence_Option_Alts = Core.Name "hydra.shex.syntax.ShexDoc_Sequence_Option_Alts"

_ShexDoc_Sequence_Option_Alts_NotStartAction = Core.Name "NotStartAction"

_ShexDoc_Sequence_Option_Alts_StartActions = Core.Name "StartActions"

data Directive =
  DirectiveBaseDecl BaseDecl |
  DirectivePrefixDecl PrefixDecl
  deriving (Eq, Ord, Read, Show)

_Directive = Core.Name "hydra.shex.syntax.Directive"

_Directive_BaseDecl = Core.Name "BaseDecl"

_Directive_PrefixDecl = Core.Name "PrefixDecl"

newtype BaseDecl =
  BaseDecl {
    unBaseDecl :: IriRef}
  deriving (Eq, Ord, Read, Show)

_BaseDecl = Core.Name "hydra.shex.syntax.BaseDecl"

data PrefixDecl =
  PrefixDecl {
    prefixDeclPnameNs :: PnameNs,
    prefixDeclIriRef :: IriRef}
  deriving (Eq, Ord, Read, Show)

_PrefixDecl = Core.Name "hydra.shex.syntax.PrefixDecl"

_PrefixDecl_PnameNs = Core.Name "PnameNs"

_PrefixDecl_IriRef = Core.Name "IriRef"

data NotStartAction =
  NotStartActionStart ShapeExpression |
  NotStartActionShapeExprDecl NotStartAction_ShapeExprDecl
  deriving (Eq, Ord, Read, Show)

_NotStartAction = Core.Name "hydra.shex.syntax.NotStartAction"

_NotStartAction_start = Core.Name "start"

_NotStartAction_shapeExprDecl = Core.Name "shapeExprDecl"

data NotStartAction_ShapeExprDecl =
  NotStartAction_ShapeExprDecl {
    notStartAction_ShapeExprDeclShapeExprLabel :: ShapeExprLabel,
    notStartAction_ShapeExprDeclAlts :: NotStartAction_ShapeExprDecl_Alts}
  deriving (Eq, Ord, Read, Show)

_NotStartAction_ShapeExprDecl = Core.Name "hydra.shex.syntax.NotStartAction_ShapeExprDecl"

_NotStartAction_ShapeExprDecl_ShapeExprLabel = Core.Name "ShapeExprLabel"

_NotStartAction_ShapeExprDecl_alts = Core.Name "alts"

data NotStartAction_ShapeExprDecl_Alts =
  NotStartAction_ShapeExprDecl_AltsShapeExpression ShapeExpression |
  NotStartAction_ShapeExprDecl_AltsEXTERNAL
  deriving (Eq, Ord, Read, Show)

_NotStartAction_ShapeExprDecl_Alts = Core.Name "hydra.shex.syntax.NotStartAction_ShapeExprDecl_Alts"

_NotStartAction_ShapeExprDecl_Alts_ShapeExpression = Core.Name "ShapeExpression"

_NotStartAction_ShapeExprDecl_Alts_EXTERNAL = Core.Name "EXTERNAL"

newtype StartActions =
  StartActions {
    unStartActions :: [CodeDecl]}
  deriving (Eq, Ord, Read, Show)

_StartActions = Core.Name "hydra.shex.syntax.StartActions"

data Statement =
  StatementDirective Directive |
  StatementNotStartAction NotStartAction
  deriving (Eq, Ord, Read, Show)

_Statement = Core.Name "hydra.shex.syntax.Statement"

_Statement_Directive = Core.Name "Directive"

_Statement_NotStartAction = Core.Name "NotStartAction"

newtype ShapeExpression =
  ShapeExpression {
    unShapeExpression :: ShapeOr}
  deriving (Eq, Ord, Read, Show)

_ShapeExpression = Core.Name "hydra.shex.syntax.ShapeExpression"

newtype InlineShapeExpression =
  InlineShapeExpression {
    unInlineShapeExpression :: InlineShapeOr}
  deriving (Eq, Ord, Read, Show)

_InlineShapeExpression = Core.Name "hydra.shex.syntax.InlineShapeExpression"

data ShapeOr =
  ShapeOr {
    shapeOrShapeAnd :: ShapeAnd,
    shapeOrListOfSequence :: [ShapeAnd]}
  deriving (Eq, Ord, Read, Show)

_ShapeOr = Core.Name "hydra.shex.syntax.ShapeOr"

_ShapeOr_ShapeAnd = Core.Name "ShapeAnd"

_ShapeOr_listOfSequence = Core.Name "listOfSequence"

data InlineShapeOr =
  InlineShapeOr {
    inlineShapeOrShapeAnd :: ShapeAnd,
    inlineShapeOrListOfSequence :: [InlineShapeAnd]}
  deriving (Eq, Ord, Read, Show)

_InlineShapeOr = Core.Name "hydra.shex.syntax.InlineShapeOr"

_InlineShapeOr_ShapeAnd = Core.Name "ShapeAnd"

_InlineShapeOr_listOfSequence = Core.Name "listOfSequence"

data ShapeAnd =
  ShapeAnd {
    shapeAndShapeNot :: ShapeNot,
    shapeAndListOfSequence :: [ShapeNot]}
  deriving (Eq, Ord, Read, Show)

_ShapeAnd = Core.Name "hydra.shex.syntax.ShapeAnd"

_ShapeAnd_ShapeNot = Core.Name "ShapeNot"

_ShapeAnd_listOfSequence = Core.Name "listOfSequence"

data InlineShapeAnd =
  InlineShapeAnd {
    inlineShapeAndInlineShapeNot :: InlineShapeNot,
    inlineShapeAndListOfSequence :: [InlineShapeNot]}
  deriving (Eq, Ord, Read, Show)

_InlineShapeAnd = Core.Name "hydra.shex.syntax.InlineShapeAnd"

_InlineShapeAnd_InlineShapeNot = Core.Name "InlineShapeNot"

_InlineShapeAnd_listOfSequence = Core.Name "listOfSequence"

data ShapeNot =
  ShapeNot {
    shapeNotNOT :: (Maybe ()),
    shapeNotShapeAtom :: ShapeAtom}
  deriving (Eq, Ord, Read, Show)

_ShapeNot = Core.Name "hydra.shex.syntax.ShapeNot"

_ShapeNot_NOT = Core.Name "NOT"

_ShapeNot_ShapeAtom = Core.Name "ShapeAtom"

data InlineShapeNot =
  InlineShapeNot {
    inlineShapeNotNOT :: (Maybe ()),
    inlineShapeNotInlineShapeAtom :: InlineShapeAtom}
  deriving (Eq, Ord, Read, Show)

_InlineShapeNot = Core.Name "hydra.shex.syntax.InlineShapeNot"

_InlineShapeNot_NOT = Core.Name "NOT"

_InlineShapeNot_InlineShapeAtom = Core.Name "InlineShapeAtom"

data ShapeAtom =
  ShapeAtomSequence ShapeAtom_Sequence |
  ShapeAtomShapeOrRef ShapeOrRef |
  ShapeAtomSequence2 ShapeExpression |
  ShapeAtomPeriod
  deriving (Eq, Ord, Read, Show)

_ShapeAtom = Core.Name "hydra.shex.syntax.ShapeAtom"

_ShapeAtom_sequence = Core.Name "sequence"

_ShapeAtom_ShapeOrRef = Core.Name "ShapeOrRef"

_ShapeAtom_sequence2 = Core.Name "sequence2"

_ShapeAtom_Period = Core.Name "Period"

data ShapeAtom_Sequence =
  ShapeAtom_Sequence {
    shapeAtom_SequenceNodeConstraint :: NodeConstraint,
    shapeAtom_SequenceShapeOrRef :: (Maybe ShapeOrRef)}
  deriving (Eq, Ord, Read, Show)

_ShapeAtom_Sequence = Core.Name "hydra.shex.syntax.ShapeAtom_Sequence"

_ShapeAtom_Sequence_NodeConstraint = Core.Name "NodeConstraint"

_ShapeAtom_Sequence_ShapeOrRef = Core.Name "ShapeOrRef"

data InlineShapeAtom =
  InlineShapeAtomSequence InlineShapeAtom_Sequence |
  InlineShapeAtomSequence2 InlineShapeAtom_Sequence2 |
  InlineShapeAtomSequence3 ShapeExpression |
  InlineShapeAtomPeriod
  deriving (Eq, Ord, Read, Show)

_InlineShapeAtom = Core.Name "hydra.shex.syntax.InlineShapeAtom"

_InlineShapeAtom_sequence = Core.Name "sequence"

_InlineShapeAtom_sequence2 = Core.Name "sequence2"

_InlineShapeAtom_sequence3 = Core.Name "sequence3"

_InlineShapeAtom_Period = Core.Name "Period"

data InlineShapeAtom_Sequence =
  InlineShapeAtom_Sequence {
    inlineShapeAtom_SequenceNodeConstraint :: NodeConstraint,
    inlineShapeAtom_SequenceInlineShapeOrRef :: (Maybe InlineShapeOrRef)}
  deriving (Eq, Ord, Read, Show)

_InlineShapeAtom_Sequence = Core.Name "hydra.shex.syntax.InlineShapeAtom_Sequence"

_InlineShapeAtom_Sequence_NodeConstraint = Core.Name "NodeConstraint"

_InlineShapeAtom_Sequence_InlineShapeOrRef = Core.Name "InlineShapeOrRef"

data InlineShapeAtom_Sequence2 =
  InlineShapeAtom_Sequence2 {
    inlineShapeAtom_Sequence2InlineShapeOrRef :: InlineShapeOrRef,
    inlineShapeAtom_Sequence2NodeConstraint :: (Maybe NodeConstraint)}
  deriving (Eq, Ord, Read, Show)

_InlineShapeAtom_Sequence2 = Core.Name "hydra.shex.syntax.InlineShapeAtom_Sequence2"

_InlineShapeAtom_Sequence2_InlineShapeOrRef = Core.Name "InlineShapeOrRef"

_InlineShapeAtom_Sequence2_NodeConstraint = Core.Name "NodeConstraint"

data ShapeOrRef =
  ShapeOrRefShapeDefinition ShapeDefinition |
  ShapeOrRefAtpNameLn AtpNameLn |
  ShapeOrRefAtpNameNs AtpNameNs |
  ShapeOrRefSequence ShapeExprLabel
  deriving (Eq, Ord, Read, Show)

_ShapeOrRef = Core.Name "hydra.shex.syntax.ShapeOrRef"

_ShapeOrRef_ShapeDefinition = Core.Name "ShapeDefinition"

_ShapeOrRef_AtpNameLn = Core.Name "AtpNameLn"

_ShapeOrRef_AtpNameNs = Core.Name "AtpNameNs"

_ShapeOrRef_sequence = Core.Name "sequence"

data InlineShapeOrRef =
  InlineShapeOrRefInlineShapeDefinition InlineShapeDefinition |
  InlineShapeOrRefAtpNameLn AtpNameLn |
  InlineShapeOrRefAtpNameNs AtpNameNs |
  InlineShapeOrRefSequence ShapeExprLabel
  deriving (Eq, Ord, Read, Show)

_InlineShapeOrRef = Core.Name "hydra.shex.syntax.InlineShapeOrRef"

_InlineShapeOrRef_InlineShapeDefinition = Core.Name "InlineShapeDefinition"

_InlineShapeOrRef_AtpNameLn = Core.Name "AtpNameLn"

_InlineShapeOrRef_AtpNameNs = Core.Name "AtpNameNs"

_InlineShapeOrRef_sequence = Core.Name "sequence"

data NodeConstraint =
  NodeConstraintSequence [XsFacet] |
  NodeConstraintSequence2 NodeConstraint_Sequence2 |
  NodeConstraintSequence3 NodeConstraint_Sequence3 |
  NodeConstraintSequence4 NodeConstraint_Sequence4 |
  NodeConstraintSequence5 NodeConstraint_Sequence5 |
  NodeConstraintListOfXsFacet [XsFacet]
  deriving (Eq, Ord, Read, Show)

_NodeConstraint = Core.Name "hydra.shex.syntax.NodeConstraint"

_NodeConstraint_sequence = Core.Name "sequence"

_NodeConstraint_sequence2 = Core.Name "sequence2"

_NodeConstraint_sequence3 = Core.Name "sequence3"

_NodeConstraint_sequence4 = Core.Name "sequence4"

_NodeConstraint_sequence5 = Core.Name "sequence5"

_NodeConstraint_listOfXsFacet = Core.Name "listOfXsFacet"

data NodeConstraint_Sequence2 =
  NodeConstraint_Sequence2 {
    nodeConstraint_Sequence2NonLiteralKind :: NonLiteralKind,
    nodeConstraint_Sequence2ListOfStringFacet :: [StringFacet]}
  deriving (Eq, Ord, Read, Show)

_NodeConstraint_Sequence2 = Core.Name "hydra.shex.syntax.NodeConstraint_Sequence2"

_NodeConstraint_Sequence2_NonLiteralKind = Core.Name "NonLiteralKind"

_NodeConstraint_Sequence2_listOfStringFacet = Core.Name "listOfStringFacet"

data NodeConstraint_Sequence3 =
  NodeConstraint_Sequence3 {
    nodeConstraint_Sequence3Datatype :: Datatype,
    nodeConstraint_Sequence3ListOfXsFacet :: [XsFacet]}
  deriving (Eq, Ord, Read, Show)

_NodeConstraint_Sequence3 = Core.Name "hydra.shex.syntax.NodeConstraint_Sequence3"

_NodeConstraint_Sequence3_Datatype = Core.Name "Datatype"

_NodeConstraint_Sequence3_listOfXsFacet = Core.Name "listOfXsFacet"

data NodeConstraint_Sequence4 =
  NodeConstraint_Sequence4 {
    nodeConstraint_Sequence4ValueSet :: ValueSet,
    nodeConstraint_Sequence4ListOfXsFacet :: [XsFacet]}
  deriving (Eq, Ord, Read, Show)

_NodeConstraint_Sequence4 = Core.Name "hydra.shex.syntax.NodeConstraint_Sequence4"

_NodeConstraint_Sequence4_ValueSet = Core.Name "ValueSet"

_NodeConstraint_Sequence4_listOfXsFacet = Core.Name "listOfXsFacet"

data NodeConstraint_Sequence5 =
  NodeConstraint_Sequence5 {
    nodeConstraint_Sequence5ValueSet :: ValueSet,
    nodeConstraint_Sequence5ListOfXsFacet :: [XsFacet]}
  deriving (Eq, Ord, Read, Show)

_NodeConstraint_Sequence5 = Core.Name "hydra.shex.syntax.NodeConstraint_Sequence5"

_NodeConstraint_Sequence5_ValueSet = Core.Name "ValueSet"

_NodeConstraint_Sequence5_listOfXsFacet = Core.Name "listOfXsFacet"

data NonLiteralKind =
  NonLiteralKindIRI  |
  NonLiteralKindBNODE  |
  NonLiteralKindNONLITERAL
  deriving (Eq, Ord, Read, Show)

_NonLiteralKind = Core.Name "hydra.shex.syntax.NonLiteralKind"

_NonLiteralKind_IRI = Core.Name "IRI"

_NonLiteralKind_BNODE = Core.Name "BNODE"

_NonLiteralKind_NONLITERAL = Core.Name "NONLITERAL"

data XsFacet =
  XsFacetStringFacet StringFacet |
  XsFacetNumericFacet NumericFacet
  deriving (Eq, Ord, Read, Show)

_XsFacet = Core.Name "hydra.shex.syntax.XsFacet"

_XsFacet_StringFacet = Core.Name "StringFacet"

_XsFacet_NumericFacet = Core.Name "NumericFacet"

data StringFacet =
  StringFacetSequence StringFacet_Sequence |
  StringFacetRegexp Regexp
  deriving (Eq, Ord, Read, Show)

_StringFacet = Core.Name "hydra.shex.syntax.StringFacet"

_StringFacet_sequence = Core.Name "sequence"

_StringFacet_Regexp = Core.Name "Regexp"

data StringFacet_Sequence =
  StringFacet_Sequence {
    stringFacet_SequenceStringLength :: StringLength,
    stringFacet_SequenceInteger :: Integer_}
  deriving (Eq, Ord, Read, Show)

_StringFacet_Sequence = Core.Name "hydra.shex.syntax.StringFacet_Sequence"

_StringFacet_Sequence_StringLength = Core.Name "StringLength"

_StringFacet_Sequence_Integer = Core.Name "Integer"

data StringLength =
  StringLengthLENGTH  |
  StringLengthMINLENGTH  |
  StringLengthMAXLENGTH
  deriving (Eq, Ord, Read, Show)

_StringLength = Core.Name "hydra.shex.syntax.StringLength"

_StringLength_LENGTH = Core.Name "LENGTH"

_StringLength_MINLENGTH = Core.Name "MINLENGTH"

_StringLength_MAXLENGTH = Core.Name "MAXLENGTH"

data NumericFacet =
  NumericFacetSequence NumericFacet_Sequence |
  NumericFacetSequence2 NumericFacet_Sequence2
  deriving (Eq, Ord, Read, Show)

_NumericFacet = Core.Name "hydra.shex.syntax.NumericFacet"

_NumericFacet_sequence = Core.Name "sequence"

_NumericFacet_sequence2 = Core.Name "sequence2"

data NumericFacet_Sequence =
  NumericFacet_Sequence {
    numericFacet_SequenceNumericRange :: NumericRange,
    numericFacet_SequenceNumericLiteral :: NumericLiteral}
  deriving (Eq, Ord, Read, Show)

_NumericFacet_Sequence = Core.Name "hydra.shex.syntax.NumericFacet_Sequence"

_NumericFacet_Sequence_NumericRange = Core.Name "NumericRange"

_NumericFacet_Sequence_NumericLiteral = Core.Name "NumericLiteral"

data NumericFacet_Sequence2 =
  NumericFacet_Sequence2 {
    numericFacet_Sequence2NumericLength :: NumericLength,
    numericFacet_Sequence2Integer :: Integer_}
  deriving (Eq, Ord, Read, Show)

_NumericFacet_Sequence2 = Core.Name "hydra.shex.syntax.NumericFacet_Sequence2"

_NumericFacet_Sequence2_NumericLength = Core.Name "NumericLength"

_NumericFacet_Sequence2_Integer = Core.Name "Integer"

data NumericRange =
  NumericRangeMININCLUSIVE  |
  NumericRangeMINEXCLUSIVE  |
  NumericRangeMAXINCLUSIVE  |
  NumericRangeMAXEXCLUSIVE
  deriving (Eq, Ord, Read, Show)

_NumericRange = Core.Name "hydra.shex.syntax.NumericRange"

_NumericRange_MININCLUSIVE = Core.Name "MININCLUSIVE"

_NumericRange_MINEXCLUSIVE = Core.Name "MINEXCLUSIVE"

_NumericRange_MAXINCLUSIVE = Core.Name "MAXINCLUSIVE"

_NumericRange_MAXEXCLUSIVE = Core.Name "MAXEXCLUSIVE"

data NumericLength =
  NumericLengthTOTALDIGITS  |
  NumericLengthFRACTIONDIGITS
  deriving (Eq, Ord, Read, Show)

_NumericLength = Core.Name "hydra.shex.syntax.NumericLength"

_NumericLength_TOTALDIGITS = Core.Name "TOTALDIGITS"

_NumericLength_FRACTIONDIGITS = Core.Name "FRACTIONDIGITS"

data ShapeDefinition =
  ShapeDefinition {
    shapeDefinitionListOfAlts :: [ShapeDefinition_ListOfAlts_Elmt],
    shapeDefinitionTripleExpression :: (Maybe TripleExpression),
    shapeDefinitionListOfAnnotation :: [Annotation],
    shapeDefinitionSemanticActions :: SemanticActions}
  deriving (Eq, Ord, Read, Show)

_ShapeDefinition = Core.Name "hydra.shex.syntax.ShapeDefinition"

_ShapeDefinition_listOfAlts = Core.Name "listOfAlts"

_ShapeDefinition_TripleExpression = Core.Name "TripleExpression"

_ShapeDefinition_listOfAnnotation = Core.Name "listOfAnnotation"

_ShapeDefinition_SemanticActions = Core.Name "SemanticActions"

data ShapeDefinition_ListOfAlts_Elmt =
  ShapeDefinition_ListOfAlts_ElmtIncludeSet IncludeSet |
  ShapeDefinition_ListOfAlts_ElmtExtraPropertySet ExtraPropertySet |
  ShapeDefinition_ListOfAlts_ElmtCLOSED
  deriving (Eq, Ord, Read, Show)

_ShapeDefinition_ListOfAlts_Elmt = Core.Name "hydra.shex.syntax.ShapeDefinition_ListOfAlts_Elmt"

_ShapeDefinition_ListOfAlts_Elmt_IncludeSet = Core.Name "IncludeSet"

_ShapeDefinition_ListOfAlts_Elmt_ExtraPropertySet = Core.Name "ExtraPropertySet"

_ShapeDefinition_ListOfAlts_Elmt_CLOSED = Core.Name "CLOSED"

data InlineShapeDefinition =
  InlineShapeDefinition {
    inlineShapeDefinitionListOfAlts :: [InlineShapeDefinition_ListOfAlts_Elmt],
    inlineShapeDefinitionTripleExpression :: (Maybe TripleExpression)}
  deriving (Eq, Ord, Read, Show)

_InlineShapeDefinition = Core.Name "hydra.shex.syntax.InlineShapeDefinition"

_InlineShapeDefinition_listOfAlts = Core.Name "listOfAlts"

_InlineShapeDefinition_TripleExpression = Core.Name "TripleExpression"

data InlineShapeDefinition_ListOfAlts_Elmt =
  InlineShapeDefinition_ListOfAlts_ElmtIncludeSet IncludeSet |
  InlineShapeDefinition_ListOfAlts_ElmtExtraPropertySet ExtraPropertySet |
  InlineShapeDefinition_ListOfAlts_ElmtCLOSED
  deriving (Eq, Ord, Read, Show)

_InlineShapeDefinition_ListOfAlts_Elmt = Core.Name "hydra.shex.syntax.InlineShapeDefinition_ListOfAlts_Elmt"

_InlineShapeDefinition_ListOfAlts_Elmt_IncludeSet = Core.Name "IncludeSet"

_InlineShapeDefinition_ListOfAlts_Elmt_ExtraPropertySet = Core.Name "ExtraPropertySet"

_InlineShapeDefinition_ListOfAlts_Elmt_CLOSED = Core.Name "CLOSED"

newtype ExtraPropertySet =
  ExtraPropertySet {
    unExtraPropertySet :: [Predicate]}
  deriving (Eq, Ord, Read, Show)

_ExtraPropertySet = Core.Name "hydra.shex.syntax.ExtraPropertySet"

newtype TripleExpression =
  TripleExpression {
    unTripleExpression :: OneOfTripleExpr}
  deriving (Eq, Ord, Read, Show)

_TripleExpression = Core.Name "hydra.shex.syntax.TripleExpression"

data OneOfTripleExpr =
  OneOfTripleExprGroupTripleExpr GroupTripleExpr |
  OneOfTripleExprMultiElementOneOf MultiElementOneOf
  deriving (Eq, Ord, Read, Show)

_OneOfTripleExpr = Core.Name "hydra.shex.syntax.OneOfTripleExpr"

_OneOfTripleExpr_GroupTripleExpr = Core.Name "GroupTripleExpr"

_OneOfTripleExpr_MultiElementOneOf = Core.Name "MultiElementOneOf"

data MultiElementOneOf =
  MultiElementOneOf {
    multiElementOneOfGroupTripleExpr :: GroupTripleExpr,
    multiElementOneOfListOfSequence :: [GroupTripleExpr]}
  deriving (Eq, Ord, Read, Show)

_MultiElementOneOf = Core.Name "hydra.shex.syntax.MultiElementOneOf"

_MultiElementOneOf_GroupTripleExpr = Core.Name "GroupTripleExpr"

_MultiElementOneOf_listOfSequence = Core.Name "listOfSequence"

data InnerTripleExpr =
  InnerTripleExprMultiElementGroup MultiElementGroup |
  InnerTripleExprMultiElementOneOf MultiElementOneOf
  deriving (Eq, Ord, Read, Show)

_InnerTripleExpr = Core.Name "hydra.shex.syntax.InnerTripleExpr"

_InnerTripleExpr_MultiElementGroup = Core.Name "MultiElementGroup"

_InnerTripleExpr_MultiElementOneOf = Core.Name "MultiElementOneOf"

data GroupTripleExpr =
  GroupTripleExprSingleElementGroup SingleElementGroup |
  GroupTripleExprMultiElementGroup MultiElementGroup
  deriving (Eq, Ord, Read, Show)

_GroupTripleExpr = Core.Name "hydra.shex.syntax.GroupTripleExpr"

_GroupTripleExpr_SingleElementGroup = Core.Name "SingleElementGroup"

_GroupTripleExpr_MultiElementGroup = Core.Name "MultiElementGroup"

data SingleElementGroup =
  SingleElementGroup {
    singleElementGroupUnaryTripleExpr :: UnaryTripleExpr,
    singleElementGroupSemi :: (Maybe ())}
  deriving (Eq, Ord, Read, Show)

_SingleElementGroup = Core.Name "hydra.shex.syntax.SingleElementGroup"

_SingleElementGroup_UnaryTripleExpr = Core.Name "UnaryTripleExpr"

_SingleElementGroup_Semi = Core.Name "Semi"

data MultiElementGroup =
  MultiElementGroup {
    multiElementGroupUnaryTripleExpr :: UnaryTripleExpr,
    multiElementGroupListOfSequence :: [UnaryTripleExpr],
    multiElementGroupSemi :: (Maybe ())}
  deriving (Eq, Ord, Read, Show)

_MultiElementGroup = Core.Name "hydra.shex.syntax.MultiElementGroup"

_MultiElementGroup_UnaryTripleExpr = Core.Name "UnaryTripleExpr"

_MultiElementGroup_listOfSequence = Core.Name "listOfSequence"

_MultiElementGroup_Semi = Core.Name "Semi"

data UnaryTripleExpr =
  UnaryTripleExprSequence UnaryTripleExpr_Sequence |
  UnaryTripleExprInclude Include
  deriving (Eq, Ord, Read, Show)

_UnaryTripleExpr = Core.Name "hydra.shex.syntax.UnaryTripleExpr"

_UnaryTripleExpr_sequence = Core.Name "sequence"

_UnaryTripleExpr_Include = Core.Name "Include"

data UnaryTripleExpr_Sequence =
  UnaryTripleExpr_Sequence {
    unaryTripleExpr_SequenceSequence :: (Maybe TripleExprLabel),
    unaryTripleExpr_SequenceAlts :: UnaryTripleExpr_Sequence_Alts}
  deriving (Eq, Ord, Read, Show)

_UnaryTripleExpr_Sequence = Core.Name "hydra.shex.syntax.UnaryTripleExpr_Sequence"

_UnaryTripleExpr_Sequence_Sequence = Core.Name "Sequence"

_UnaryTripleExpr_Sequence_alts = Core.Name "alts"

data UnaryTripleExpr_Sequence_Alts =
  UnaryTripleExpr_Sequence_AltsTripleConstraint TripleConstraint |
  UnaryTripleExpr_Sequence_AltsBracketedTripleExpr BracketedTripleExpr
  deriving (Eq, Ord, Read, Show)

_UnaryTripleExpr_Sequence_Alts = Core.Name "hydra.shex.syntax.UnaryTripleExpr_Sequence_Alts"

_UnaryTripleExpr_Sequence_Alts_TripleConstraint = Core.Name "TripleConstraint"

_UnaryTripleExpr_Sequence_Alts_BracketedTripleExpr = Core.Name "BracketedTripleExpr"

data BracketedTripleExpr =
  BracketedTripleExpr {
    bracketedTripleExprInnerTripleExpr :: InnerTripleExpr,
    bracketedTripleExprCardinality :: (Maybe Cardinality),
    bracketedTripleExprListOfAnnotation :: [Annotation],
    bracketedTripleExprSemanticActions :: SemanticActions}
  deriving (Eq, Ord, Read, Show)

_BracketedTripleExpr = Core.Name "hydra.shex.syntax.BracketedTripleExpr"

_BracketedTripleExpr_InnerTripleExpr = Core.Name "InnerTripleExpr"

_BracketedTripleExpr_Cardinality = Core.Name "Cardinality"

_BracketedTripleExpr_listOfAnnotation = Core.Name "listOfAnnotation"

_BracketedTripleExpr_SemanticActions = Core.Name "SemanticActions"

data TripleConstraint =
  TripleConstraint {
    tripleConstraintSenseFlags :: (Maybe SenseFlags),
    tripleConstraintPredicate :: Predicate,
    tripleConstraintInlineShapeExpression :: InlineShapeExpression,
    tripleConstraintCardinality :: (Maybe Cardinality),
    tripleConstraintListOfAnnotation :: [Annotation],
    tripleConstraintSemanticActions :: SemanticActions}
  deriving (Eq, Ord, Read, Show)

_TripleConstraint = Core.Name "hydra.shex.syntax.TripleConstraint"

_TripleConstraint_SenseFlags = Core.Name "SenseFlags"

_TripleConstraint_Predicate = Core.Name "Predicate"

_TripleConstraint_InlineShapeExpression = Core.Name "InlineShapeExpression"

_TripleConstraint_Cardinality = Core.Name "Cardinality"

_TripleConstraint_listOfAnnotation = Core.Name "listOfAnnotation"

_TripleConstraint_SemanticActions = Core.Name "SemanticActions"

data Cardinality =
  CardinalityAst  |
  CardinalityPlus  |
  CardinalityQuest  |
  CardinalityRepeatRange RepeatRange
  deriving (Eq, Ord, Read, Show)

_Cardinality = Core.Name "hydra.shex.syntax.Cardinality"

_Cardinality_Ast = Core.Name "Ast"

_Cardinality_Plus = Core.Name "Plus"

_Cardinality_Quest = Core.Name "Quest"

_Cardinality_RepeatRange = Core.Name "RepeatRange"

newtype SenseFlags =
  SenseFlags {
    unSenseFlags :: ()}
  deriving (Eq, Ord, Read, Show)

_SenseFlags = Core.Name "hydra.shex.syntax.SenseFlags"

newtype ValueSet =
  ValueSet {
    unValueSet :: [ValueSetValue]}
  deriving (Eq, Ord, Read, Show)

_ValueSet = Core.Name "hydra.shex.syntax.ValueSet"

data ValueSetValue =
  ValueSetValueIriRange IriRange |
  ValueSetValueLiteral Literal
  deriving (Eq, Ord, Read, Show)

_ValueSetValue = Core.Name "hydra.shex.syntax.ValueSetValue"

_ValueSetValue_IriRange = Core.Name "IriRange"

_ValueSetValue_Literal = Core.Name "Literal"

data IriRange =
  IriRangeSequence IriRange_Sequence |
  IriRangeSequence2 [Exclusion]
  deriving (Eq, Ord, Read, Show)

_IriRange = Core.Name "hydra.shex.syntax.IriRange"

_IriRange_sequence = Core.Name "sequence"

_IriRange_sequence2 = Core.Name "sequence2"

data IriRange_Sequence =
  IriRange_Sequence {
    iriRange_SequenceIri :: Iri,
    iriRange_SequenceSequence :: (Maybe [Exclusion])}
  deriving (Eq, Ord, Read, Show)

_IriRange_Sequence = Core.Name "hydra.shex.syntax.IriRange_Sequence"

_IriRange_Sequence_Iri = Core.Name "Iri"

_IriRange_Sequence_Sequence = Core.Name "Sequence"

newtype Exclusion =
  Exclusion {
    unExclusion :: Iri}
  deriving (Eq, Ord, Read, Show)

_Exclusion = Core.Name "hydra.shex.syntax.Exclusion"

newtype Include =
  Include {
    unInclude :: TripleExprLabel}
  deriving (Eq, Ord, Read, Show)

_Include = Core.Name "hydra.shex.syntax.Include"

data Annotation =
  Annotation {
    annotationPredicate :: Predicate,
    annotationAlts :: Annotation_Alts}
  deriving (Eq, Ord, Read, Show)

_Annotation = Core.Name "hydra.shex.syntax.Annotation"

_Annotation_Predicate = Core.Name "Predicate"

_Annotation_alts = Core.Name "alts"

data Annotation_Alts =
  Annotation_AltsIri Iri |
  Annotation_AltsLiteral Literal
  deriving (Eq, Ord, Read, Show)

_Annotation_Alts = Core.Name "hydra.shex.syntax.Annotation_Alts"

_Annotation_Alts_Iri = Core.Name "Iri"

_Annotation_Alts_Literal = Core.Name "Literal"

newtype SemanticActions =
  SemanticActions {
    unSemanticActions :: [CodeDecl]}
  deriving (Eq, Ord, Read, Show)

_SemanticActions = Core.Name "hydra.shex.syntax.SemanticActions"

data CodeDecl =
  CodeDecl {
    codeDeclIri :: Iri,
    codeDeclAlts :: CodeDecl_Alts}
  deriving (Eq, Ord, Read, Show)

_CodeDecl = Core.Name "hydra.shex.syntax.CodeDecl"

_CodeDecl_Iri = Core.Name "Iri"

_CodeDecl_alts = Core.Name "alts"

data CodeDecl_Alts =
  CodeDecl_AltsCode Code |
  CodeDecl_AltsPercnt
  deriving (Eq, Ord, Read, Show)

_CodeDecl_Alts = Core.Name "hydra.shex.syntax.CodeDecl_Alts"

_CodeDecl_Alts_Code = Core.Name "Code"

_CodeDecl_Alts_Percnt = Core.Name "Percnt"

data Literal =
  LiteralRdfLiteral RdfLiteral |
  LiteralNumericLiteral NumericLiteral |
  LiteralBooleanLiteral BooleanLiteral
  deriving (Eq, Ord, Read, Show)

_Literal = Core.Name "hydra.shex.syntax.Literal"

_Literal_RdfLiteral = Core.Name "RdfLiteral"

_Literal_NumericLiteral = Core.Name "NumericLiteral"

_Literal_BooleanLiteral = Core.Name "BooleanLiteral"

data Predicate =
  PredicateIri Iri |
  PredicateRdfType RdfType
  deriving (Eq, Ord, Read, Show)

_Predicate = Core.Name "hydra.shex.syntax.Predicate"

_Predicate_Iri = Core.Name "Iri"

_Predicate_RdfType = Core.Name "RdfType"

newtype Datatype =
  Datatype {
    unDatatype :: Iri}
  deriving (Eq, Ord, Read, Show)

_Datatype = Core.Name "hydra.shex.syntax.Datatype"

data ShapeExprLabel =
  ShapeExprLabelIri Iri |
  ShapeExprLabelBlankNode BlankNode
  deriving (Eq, Ord, Read, Show)

_ShapeExprLabel = Core.Name "hydra.shex.syntax.ShapeExprLabel"

_ShapeExprLabel_Iri = Core.Name "Iri"

_ShapeExprLabel_BlankNode = Core.Name "BlankNode"

data TripleExprLabel =
  TripleExprLabelIri Iri |
  TripleExprLabelBlankNode BlankNode
  deriving (Eq, Ord, Read, Show)

_TripleExprLabel = Core.Name "hydra.shex.syntax.TripleExprLabel"

_TripleExprLabel_Iri = Core.Name "Iri"

_TripleExprLabel_BlankNode = Core.Name "BlankNode"

data NumericLiteral =
  NumericLiteralInteger Integer_ |
  NumericLiteralDecimal Decimal |
  NumericLiteralDouble Double_
  deriving (Eq, Ord, Read, Show)

_NumericLiteral = Core.Name "hydra.shex.syntax.NumericLiteral"

_NumericLiteral_Integer = Core.Name "Integer"

_NumericLiteral_Decimal = Core.Name "Decimal"

_NumericLiteral_Double = Core.Name "Double"

data RdfLiteral =
  RdfLiteral {
    rdfLiteralString :: String_,
    rdfLiteralAlts :: (Maybe RdfLiteral_Alts_Option)}
  deriving (Eq, Ord, Read, Show)

_RdfLiteral = Core.Name "hydra.shex.syntax.RdfLiteral"

_RdfLiteral_String = Core.Name "String"

_RdfLiteral_Alts = Core.Name "Alts"

data RdfLiteral_Alts_Option =
  RdfLiteral_Alts_OptionLangTag LangTag |
  RdfLiteral_Alts_OptionSequence Datatype
  deriving (Eq, Ord, Read, Show)

_RdfLiteral_Alts_Option = Core.Name "hydra.shex.syntax.RdfLiteral_Alts_Option"

_RdfLiteral_Alts_Option_LangTag = Core.Name "LangTag"

_RdfLiteral_Alts_Option_sequence = Core.Name "sequence"

data BooleanLiteral =
  BooleanLiteralTrue  |
  BooleanLiteralFalse
  deriving (Eq, Ord, Read, Show)

_BooleanLiteral = Core.Name "hydra.shex.syntax.BooleanLiteral"

_BooleanLiteral_True = Core.Name "True"

_BooleanLiteral_False = Core.Name "False"

data String_ =
  StringStringLiteral1 StringLiteral1 |
  StringStringLiteralLong1 StringLiteralLong1 |
  StringStringLiteral2 StringLiteral2 |
  StringStringLiteralLong2 StringLiteralLong2
  deriving (Eq, Ord, Read, Show)

_String = Core.Name "hydra.shex.syntax.String"

_String_StringLiteral1 = Core.Name "StringLiteral1"

_String_StringLiteralLong1 = Core.Name "StringLiteralLong1"

_String_StringLiteral2 = Core.Name "StringLiteral2"

_String_StringLiteralLong2 = Core.Name "StringLiteralLong2"

data Iri =
  IriIriRef IriRef |
  IriPrefixedName PrefixedName
  deriving (Eq, Ord, Read, Show)

_Iri = Core.Name "hydra.shex.syntax.Iri"

_Iri_IriRef = Core.Name "IriRef"

_Iri_PrefixedName = Core.Name "PrefixedName"

data PrefixedName =
  PrefixedNamePnameLn PnameLn |
  PrefixedNamePnameNs PnameNs
  deriving (Eq, Ord, Read, Show)

_PrefixedName = Core.Name "hydra.shex.syntax.PrefixedName"

_PrefixedName_PnameLn = Core.Name "PnameLn"

_PrefixedName_PnameNs = Core.Name "PnameNs"

newtype BlankNode =
  BlankNode {
    unBlankNode :: BlankNodeLabel}
  deriving (Eq, Ord, Read, Show)

_BlankNode = Core.Name "hydra.shex.syntax.BlankNode"

newtype IncludeSet =
  IncludeSet {
    unIncludeSet :: [ShapeExprLabel]}
  deriving (Eq, Ord, Read, Show)

_IncludeSet = Core.Name "hydra.shex.syntax.IncludeSet"

newtype Code =
  Code {
    unCode :: [Code_Elmt]}
  deriving (Eq, Ord, Read, Show)

_Code = Core.Name "hydra.shex.syntax.Code"

data Code_Elmt =
  Code_ElmtRegex String |
  Code_ElmtSequence String |
  Code_ElmtUchar Uchar
  deriving (Eq, Ord, Read, Show)

_Code_Elmt = Core.Name "hydra.shex.syntax.Code_Elmt"

_Code_Elmt_regex = Core.Name "regex"

_Code_Elmt_sequence = Core.Name "sequence"

_Code_Elmt_Uchar = Core.Name "Uchar"

data RepeatRange =
  RepeatRange {
    repeatRangeInteger :: Integer_,
    repeatRangeSequence :: (Maybe (Maybe (Maybe RepeatRange_Sequence_Option_Option_Option)))}
  deriving (Eq, Ord, Read, Show)

_RepeatRange = Core.Name "hydra.shex.syntax.RepeatRange"

_RepeatRange_Integer = Core.Name "Integer"

_RepeatRange_Sequence = Core.Name "Sequence"

data RepeatRange_Sequence_Option_Option_Option =
  RepeatRange_Sequence_Option_Option_OptionInteger Integer_ |
  RepeatRange_Sequence_Option_Option_OptionAst
  deriving (Eq, Ord, Read, Show)

_RepeatRange_Sequence_Option_Option_Option = Core.Name "hydra.shex.syntax.RepeatRange_Sequence_Option_Option_Option"

_RepeatRange_Sequence_Option_Option_Option_Integer = Core.Name "Integer"

_RepeatRange_Sequence_Option_Option_Option_Ast = Core.Name "Ast"

newtype RdfType =
  RdfType {
    unRdfType :: ()}
  deriving (Eq, Ord, Read, Show)

_RdfType = Core.Name "hydra.shex.syntax.RdfType"

newtype IriRef =
  IriRef {
    unIriRef :: [IriRef_Elmt]}
  deriving (Eq, Ord, Read, Show)

_IriRef = Core.Name "hydra.shex.syntax.IriRef"

data IriRef_Elmt =
  IriRef_ElmtRegex String |
  IriRef_ElmtUchar Uchar
  deriving (Eq, Ord, Read, Show)

_IriRef_Elmt = Core.Name "hydra.shex.syntax.IriRef_Elmt"

_IriRef_Elmt_regex = Core.Name "regex"

_IriRef_Elmt_Uchar = Core.Name "Uchar"

newtype PnameNs =
  PnameNs {
    unPnameNs :: (Maybe PnPrefix)}
  deriving (Eq, Ord, Read, Show)

_PnameNs = Core.Name "hydra.shex.syntax.PnameNs"

data PnameLn =
  PnameLn {
    pnameLnPnameNs :: PnameNs,
    pnameLnPnLocal :: PnLocal}
  deriving (Eq, Ord, Read, Show)

_PnameLn = Core.Name "hydra.shex.syntax.PnameLn"

_PnameLn_PnameNs = Core.Name "PnameNs"

_PnameLn_PnLocal = Core.Name "PnLocal"

newtype AtpNameNs =
  AtpNameNs {
    unAtpNameNs :: (Maybe PnPrefix)}
  deriving (Eq, Ord, Read, Show)

_AtpNameNs = Core.Name "hydra.shex.syntax.AtpNameNs"

data AtpNameLn =
  AtpNameLn {
    atpNameLnPnameNs :: PnameNs,
    atpNameLnPnLocal :: PnLocal}
  deriving (Eq, Ord, Read, Show)

_AtpNameLn = Core.Name "hydra.shex.syntax.AtpNameLn"

_AtpNameLn_PnameNs = Core.Name "PnameNs"

_AtpNameLn_PnLocal = Core.Name "PnLocal"

data Regexp =
  Regexp {
    regexpListOfAlts :: [Regexp_ListOfAlts_Elmt],
    regexpListOfRegex :: [String]}
  deriving (Eq, Ord, Read, Show)

_Regexp = Core.Name "hydra.shex.syntax.Regexp"

_Regexp_listOfAlts = Core.Name "listOfAlts"

_Regexp_listOfRegex = Core.Name "listOfRegex"

data Regexp_ListOfAlts_Elmt =
  Regexp_ListOfAlts_ElmtRegex String |
  Regexp_ListOfAlts_ElmtSequence String |
  Regexp_ListOfAlts_ElmtUchar Uchar
  deriving (Eq, Ord, Read, Show)

_Regexp_ListOfAlts_Elmt = Core.Name "hydra.shex.syntax.Regexp_ListOfAlts_Elmt"

_Regexp_ListOfAlts_Elmt_regex = Core.Name "regex"

_Regexp_ListOfAlts_Elmt_sequence = Core.Name "sequence"

_Regexp_ListOfAlts_Elmt_Uchar = Core.Name "Uchar"

data BlankNodeLabel =
  BlankNodeLabel {
    blankNodeLabelAlts :: BlankNodeLabel_Alts,
    blankNodeLabelListOfAlts :: (Maybe [BlankNodeLabel_ListOfAlts_Option_Elmt]),
    blankNodeLabelPnChars :: PnChars}
  deriving (Eq, Ord, Read, Show)

_BlankNodeLabel = Core.Name "hydra.shex.syntax.BlankNodeLabel"

_BlankNodeLabel_alts = Core.Name "alts"

_BlankNodeLabel_ListOfAlts = Core.Name "ListOfAlts"

_BlankNodeLabel_PnChars = Core.Name "PnChars"

data BlankNodeLabel_Alts =
  BlankNodeLabel_AltsPnCharsU PnCharsU |
  BlankNodeLabel_AltsRegex String
  deriving (Eq, Ord, Read, Show)

_BlankNodeLabel_Alts = Core.Name "hydra.shex.syntax.BlankNodeLabel_Alts"

_BlankNodeLabel_Alts_PnCharsU = Core.Name "PnCharsU"

_BlankNodeLabel_Alts_regex = Core.Name "regex"

data BlankNodeLabel_ListOfAlts_Option_Elmt =
  BlankNodeLabel_ListOfAlts_Option_ElmtPnChars PnChars |
  BlankNodeLabel_ListOfAlts_Option_ElmtPeriod
  deriving (Eq, Ord, Read, Show)

_BlankNodeLabel_ListOfAlts_Option_Elmt = Core.Name "hydra.shex.syntax.BlankNodeLabel_ListOfAlts_Option_Elmt"

_BlankNodeLabel_ListOfAlts_Option_Elmt_PnChars = Core.Name "PnChars"

_BlankNodeLabel_ListOfAlts_Option_Elmt_Period = Core.Name "Period"

newtype LangTag =
  LangTag {
    unLangTag :: String}
  deriving (Eq, Ord, Read, Show)

_LangTag = Core.Name "hydra.shex.syntax.LangTag"

newtype Integer_ =
  Integer_ {
    unInteger :: String}
  deriving (Eq, Ord, Read, Show)

_Integer = Core.Name "hydra.shex.syntax.Integer"

newtype Decimal =
  Decimal {
    unDecimal :: String}
  deriving (Eq, Ord, Read, Show)

_Decimal = Core.Name "hydra.shex.syntax.Decimal"

newtype Double_ =
  Double_ {
    unDouble :: String}
  deriving (Eq, Ord, Read, Show)

_Double = Core.Name "hydra.shex.syntax.Double"

newtype StringLiteral1 =
  StringLiteral1 {
    unStringLiteral1 :: [StringLiteral1_Elmt]}
  deriving (Eq, Ord, Read, Show)

_StringLiteral1 = Core.Name "hydra.shex.syntax.StringLiteral1"

data StringLiteral1_Elmt =
  StringLiteral1_ElmtRegex String |
  StringLiteral1_ElmtEchar Echar |
  StringLiteral1_ElmtUchar Uchar
  deriving (Eq, Ord, Read, Show)

_StringLiteral1_Elmt = Core.Name "hydra.shex.syntax.StringLiteral1_Elmt"

_StringLiteral1_Elmt_regex = Core.Name "regex"

_StringLiteral1_Elmt_Echar = Core.Name "Echar"

_StringLiteral1_Elmt_Uchar = Core.Name "Uchar"

newtype StringLiteral2 =
  StringLiteral2 {
    unStringLiteral2 :: [StringLiteral2_Elmt]}
  deriving (Eq, Ord, Read, Show)

_StringLiteral2 = Core.Name "hydra.shex.syntax.StringLiteral2"

data StringLiteral2_Elmt =
  StringLiteral2_ElmtRegex String |
  StringLiteral2_ElmtEchar Echar |
  StringLiteral2_ElmtUchar Uchar
  deriving (Eq, Ord, Read, Show)

_StringLiteral2_Elmt = Core.Name "hydra.shex.syntax.StringLiteral2_Elmt"

_StringLiteral2_Elmt_regex = Core.Name "regex"

_StringLiteral2_Elmt_Echar = Core.Name "Echar"

_StringLiteral2_Elmt_Uchar = Core.Name "Uchar"

newtype StringLiteralLong1 =
  StringLiteralLong1 {
    unStringLiteralLong1 :: [StringLiteralLong1_Elmt]}
  deriving (Eq, Ord, Read, Show)

_StringLiteralLong1 = Core.Name "hydra.shex.syntax.StringLiteralLong1"

data StringLiteralLong1_Elmt =
  StringLiteralLong1_ElmtSequence StringLiteralLong1_Elmt_Sequence |
  StringLiteralLong1_ElmtEchar Echar |
  StringLiteralLong1_ElmtUchar Uchar
  deriving (Eq, Ord, Read, Show)

_StringLiteralLong1_Elmt = Core.Name "hydra.shex.syntax.StringLiteralLong1_Elmt"

_StringLiteralLong1_Elmt_sequence = Core.Name "sequence"

_StringLiteralLong1_Elmt_Echar = Core.Name "Echar"

_StringLiteralLong1_Elmt_Uchar = Core.Name "Uchar"

data StringLiteralLong1_Elmt_Sequence =
  StringLiteralLong1_Elmt_Sequence {
    stringLiteralLong1_Elmt_SequenceAlts :: (Maybe StringLiteralLong1_Elmt_Sequence_Alts_Option),
    stringLiteralLong1_Elmt_SequenceRegex :: String}
  deriving (Eq, Ord, Read, Show)

_StringLiteralLong1_Elmt_Sequence = Core.Name "hydra.shex.syntax.StringLiteralLong1_Elmt_Sequence"

_StringLiteralLong1_Elmt_Sequence_Alts = Core.Name "Alts"

_StringLiteralLong1_Elmt_Sequence_regex = Core.Name "regex"

data StringLiteralLong1_Elmt_Sequence_Alts_Option =
  StringLiteralLong1_Elmt_Sequence_Alts_OptionApos  |
  StringLiteralLong1_Elmt_Sequence_Alts_OptionSequence StringLiteralLong1_Elmt_Sequence_Alts_Option_Sequence
  deriving (Eq, Ord, Read, Show)

_StringLiteralLong1_Elmt_Sequence_Alts_Option =
    Core.Name "hydra.shex.syntax.StringLiteralLong1_Elmt_Sequence_Alts_Option"

_StringLiteralLong1_Elmt_Sequence_Alts_Option_Apos = Core.Name "Apos"

_StringLiteralLong1_Elmt_Sequence_Alts_Option_sequence = Core.Name "sequence"

data StringLiteralLong1_Elmt_Sequence_Alts_Option_Sequence =
  StringLiteralLong1_Elmt_Sequence_Alts_Option_Sequence {}
  deriving (Eq, Ord, Read, Show)

_StringLiteralLong1_Elmt_Sequence_Alts_Option_Sequence =
    Core.Name "hydra.shex.syntax.StringLiteralLong1_Elmt_Sequence_Alts_Option_Sequence"

newtype StringLiteralLong2 =
  StringLiteralLong2 {
    unStringLiteralLong2 :: [StringLiteralLong2_Elmt]}
  deriving (Eq, Ord, Read, Show)

_StringLiteralLong2 = Core.Name "hydra.shex.syntax.StringLiteralLong2"

data StringLiteralLong2_Elmt =
  StringLiteralLong2_ElmtSequence StringLiteralLong2_Elmt_Sequence |
  StringLiteralLong2_ElmtEchar Echar |
  StringLiteralLong2_ElmtUchar Uchar
  deriving (Eq, Ord, Read, Show)

_StringLiteralLong2_Elmt = Core.Name "hydra.shex.syntax.StringLiteralLong2_Elmt"

_StringLiteralLong2_Elmt_sequence = Core.Name "sequence"

_StringLiteralLong2_Elmt_Echar = Core.Name "Echar"

_StringLiteralLong2_Elmt_Uchar = Core.Name "Uchar"

data StringLiteralLong2_Elmt_Sequence =
  StringLiteralLong2_Elmt_Sequence {
    stringLiteralLong2_Elmt_SequenceAlts :: (Maybe StringLiteralLong2_Elmt_Sequence_Alts_Option),
    stringLiteralLong2_Elmt_SequenceRegex :: String}
  deriving (Eq, Ord, Read, Show)

_StringLiteralLong2_Elmt_Sequence = Core.Name "hydra.shex.syntax.StringLiteralLong2_Elmt_Sequence"

_StringLiteralLong2_Elmt_Sequence_Alts = Core.Name "Alts"

_StringLiteralLong2_Elmt_Sequence_regex = Core.Name "regex"

data StringLiteralLong2_Elmt_Sequence_Alts_Option =
  StringLiteralLong2_Elmt_Sequence_Alts_OptionQuot  |
  StringLiteralLong2_Elmt_Sequence_Alts_OptionSequence StringLiteralLong2_Elmt_Sequence_Alts_Option_Sequence
  deriving (Eq, Ord, Read, Show)

_StringLiteralLong2_Elmt_Sequence_Alts_Option =
    Core.Name "hydra.shex.syntax.StringLiteralLong2_Elmt_Sequence_Alts_Option"

_StringLiteralLong2_Elmt_Sequence_Alts_Option_Quot = Core.Name "Quot"

_StringLiteralLong2_Elmt_Sequence_Alts_Option_sequence = Core.Name "sequence"

data StringLiteralLong2_Elmt_Sequence_Alts_Option_Sequence =
  StringLiteralLong2_Elmt_Sequence_Alts_Option_Sequence {}
  deriving (Eq, Ord, Read, Show)

_StringLiteralLong2_Elmt_Sequence_Alts_Option_Sequence =
    Core.Name "hydra.shex.syntax.StringLiteralLong2_Elmt_Sequence_Alts_Option_Sequence"

data Uchar =
  UcharSequence Uchar_Sequence |
  UcharSequence2 Uchar_Sequence2
  deriving (Eq, Ord, Read, Show)

_Uchar = Core.Name "hydra.shex.syntax.Uchar"

_Uchar_sequence = Core.Name "sequence"

_Uchar_sequence2 = Core.Name "sequence2"

data Uchar_Sequence =
  Uchar_Sequence {
    uchar_SequenceHex :: Hex,
    uchar_SequenceHex2 :: Hex,
    uchar_SequenceHex3 :: Hex,
    uchar_SequenceHex4 :: Hex}
  deriving (Eq, Ord, Read, Show)

_Uchar_Sequence = Core.Name "hydra.shex.syntax.Uchar_Sequence"

_Uchar_Sequence_Hex = Core.Name "Hex"

_Uchar_Sequence_Hex2 = Core.Name "Hex2"

_Uchar_Sequence_Hex3 = Core.Name "Hex3"

_Uchar_Sequence_Hex4 = Core.Name "Hex4"

data Uchar_Sequence2 =
  Uchar_Sequence2 {
    uchar_Sequence2Hex :: Hex,
    uchar_Sequence2Hex2 :: Hex,
    uchar_Sequence2Hex3 :: Hex,
    uchar_Sequence2Hex4 :: Hex,
    uchar_Sequence2Hex5 :: Hex,
    uchar_Sequence2Hex6 :: Hex,
    uchar_Sequence2Hex7 :: Hex,
    uchar_Sequence2Hex8 :: Hex}
  deriving (Eq, Ord, Read, Show)

_Uchar_Sequence2 = Core.Name "hydra.shex.syntax.Uchar_Sequence2"

_Uchar_Sequence2_Hex = Core.Name "Hex"

_Uchar_Sequence2_Hex2 = Core.Name "Hex2"

_Uchar_Sequence2_Hex3 = Core.Name "Hex3"

_Uchar_Sequence2_Hex4 = Core.Name "Hex4"

_Uchar_Sequence2_Hex5 = Core.Name "Hex5"

_Uchar_Sequence2_Hex6 = Core.Name "Hex6"

_Uchar_Sequence2_Hex7 = Core.Name "Hex7"

_Uchar_Sequence2_Hex8 = Core.Name "Hex8"

newtype Echar =
  Echar {
    unEchar :: String}
  deriving (Eq, Ord, Read, Show)

_Echar = Core.Name "hydra.shex.syntax.Echar"

data PnCharsBase =
  PnCharsBaseRegex String |
  PnCharsBaseRegex2 String
  deriving (Eq, Ord, Read, Show)

_PnCharsBase = Core.Name "hydra.shex.syntax.PnCharsBase"

_PnCharsBase_regex = Core.Name "regex"

_PnCharsBase_regex2 = Core.Name "regex2"

data PnCharsU =
  PnCharsUPnCharsBase PnCharsBase |
  PnCharsULowbar
  deriving (Eq, Ord, Read, Show)

_PnCharsU = Core.Name "hydra.shex.syntax.PnCharsU"

_PnCharsU_PnCharsBase = Core.Name "PnCharsBase"

_PnCharsU_Lowbar = Core.Name "Lowbar"

data PnChars =
  PnCharsPnCharsU PnCharsU |
  PnCharsMinus  |
  PnCharsRegex String
  deriving (Eq, Ord, Read, Show)

_PnChars = Core.Name "hydra.shex.syntax.PnChars"

_PnChars_PnCharsU = Core.Name "PnCharsU"

_PnChars_Minus = Core.Name "Minus"

_PnChars_regex = Core.Name "regex"

data PnPrefix =
  PnPrefix {
    pnPrefixPnCharsBase :: PnCharsBase,
    pnPrefixSequence :: (Maybe PnPrefix_Sequence_Option)}
  deriving (Eq, Ord, Read, Show)

_PnPrefix = Core.Name "hydra.shex.syntax.PnPrefix"

_PnPrefix_PnCharsBase = Core.Name "PnCharsBase"

_PnPrefix_Sequence = Core.Name "Sequence"

data PnPrefix_Sequence_Option =
  PnPrefix_Sequence_Option {
    pnPrefix_Sequence_OptionAlts :: PnPrefix_Sequence_Option_Alts,
    pnPrefix_Sequence_OptionPnChars :: PnChars}
  deriving (Eq, Ord, Read, Show)

_PnPrefix_Sequence_Option = Core.Name "hydra.shex.syntax.PnPrefix_Sequence_Option"

_PnPrefix_Sequence_Option_alts = Core.Name "alts"

_PnPrefix_Sequence_Option_PnChars = Core.Name "PnChars"

data PnPrefix_Sequence_Option_Alts =
  PnPrefix_Sequence_Option_AltsPnChars PnChars |
  PnPrefix_Sequence_Option_AltsPeriod
  deriving (Eq, Ord, Read, Show)

_PnPrefix_Sequence_Option_Alts = Core.Name "hydra.shex.syntax.PnPrefix_Sequence_Option_Alts"

_PnPrefix_Sequence_Option_Alts_PnChars = Core.Name "PnChars"

_PnPrefix_Sequence_Option_Alts_Period = Core.Name "Period"

data PnLocal =
  PnLocal {
    pnLocalAlts :: PnLocal_Alts,
    pnLocalSequence :: (Maybe PnLocal_Sequence_Option)}
  deriving (Eq, Ord, Read, Show)

_PnLocal = Core.Name "hydra.shex.syntax.PnLocal"

_PnLocal_alts = Core.Name "alts"

_PnLocal_Sequence = Core.Name "Sequence"

data PnLocal_Alts =
  PnLocal_AltsPnCharsU PnCharsU |
  PnLocal_AltsColon  |
  PnLocal_AltsRegex String |
  PnLocal_AltsPlx Plx
  deriving (Eq, Ord, Read, Show)

_PnLocal_Alts = Core.Name "hydra.shex.syntax.PnLocal_Alts"

_PnLocal_Alts_PnCharsU = Core.Name "PnCharsU"

_PnLocal_Alts_Colon = Core.Name "Colon"

_PnLocal_Alts_regex = Core.Name "regex"

_PnLocal_Alts_Plx = Core.Name "Plx"

data PnLocal_Sequence_Option =
  PnLocal_Sequence_Option {
    pnLocal_Sequence_OptionListOfAlts :: [PnLocal_Sequence_Option_ListOfAlts_Elmt],
    pnLocal_Sequence_OptionAlts :: PnLocal_Sequence_Option_Alts}
  deriving (Eq, Ord, Read, Show)

_PnLocal_Sequence_Option = Core.Name "hydra.shex.syntax.PnLocal_Sequence_Option"

_PnLocal_Sequence_Option_listOfAlts = Core.Name "listOfAlts"

_PnLocal_Sequence_Option_alts = Core.Name "alts"

data PnLocal_Sequence_Option_ListOfAlts_Elmt =
  PnLocal_Sequence_Option_ListOfAlts_ElmtPnChars PnChars |
  PnLocal_Sequence_Option_ListOfAlts_ElmtPeriod  |
  PnLocal_Sequence_Option_ListOfAlts_ElmtColon  |
  PnLocal_Sequence_Option_ListOfAlts_ElmtPlx Plx
  deriving (Eq, Ord, Read, Show)

_PnLocal_Sequence_Option_ListOfAlts_Elmt = Core.Name "hydra.shex.syntax.PnLocal_Sequence_Option_ListOfAlts_Elmt"

_PnLocal_Sequence_Option_ListOfAlts_Elmt_PnChars = Core.Name "PnChars"

_PnLocal_Sequence_Option_ListOfAlts_Elmt_Period = Core.Name "Period"

_PnLocal_Sequence_Option_ListOfAlts_Elmt_Colon = Core.Name "Colon"

_PnLocal_Sequence_Option_ListOfAlts_Elmt_Plx = Core.Name "Plx"

data PnLocal_Sequence_Option_Alts =
  PnLocal_Sequence_Option_AltsPnChars PnChars |
  PnLocal_Sequence_Option_AltsColon  |
  PnLocal_Sequence_Option_AltsPlx Plx
  deriving (Eq, Ord, Read, Show)

_PnLocal_Sequence_Option_Alts = Core.Name "hydra.shex.syntax.PnLocal_Sequence_Option_Alts"

_PnLocal_Sequence_Option_Alts_PnChars = Core.Name "PnChars"

_PnLocal_Sequence_Option_Alts_Colon = Core.Name "Colon"

_PnLocal_Sequence_Option_Alts_Plx = Core.Name "Plx"

data Plx =
  PlxPercent Percent |
  PlxPnLocalEsc PnLocalEsc
  deriving (Eq, Ord, Read, Show)

_Plx = Core.Name "hydra.shex.syntax.Plx"

_Plx_Percent = Core.Name "Percent"

_Plx_PnLocalEsc = Core.Name "PnLocalEsc"

data Percent =
  Percent {
    percentHex :: Hex,
    percentHex2 :: Hex}
  deriving (Eq, Ord, Read, Show)

_Percent = Core.Name "hydra.shex.syntax.Percent"

_Percent_Hex = Core.Name "Hex"

_Percent_Hex2 = Core.Name "Hex2"

newtype Hex =
  Hex {
    unHex :: String}
  deriving (Eq, Ord, Read, Show)

_Hex = Core.Name "hydra.shex.syntax.Hex"

newtype PnLocalEsc =
  PnLocalEsc {
    unPnLocalEsc :: String}
  deriving (Eq, Ord, Read, Show)

_PnLocalEsc = Core.Name "hydra.shex.syntax.PnLocalEsc"