hydra-0.15.0: src/main/haskell/Hydra/Cypher/OpenCypher.hs

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

-- | A Cypher model based on the OpenCypher specification (version 23), copyright Neo Technology, available at:
-- |   https://opencypher.org/resources/

module Hydra.Cypher.OpenCypher 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 Query =
  QueryRegular RegularQuery |
  QueryStandalone StandaloneCall
  deriving (Eq, Ord, Read, Show)

_Query = Core.Name "hydra.cypher.openCypher.Query"

_Query_regular = Core.Name "regular"

_Query_standalone = Core.Name "standalone"

data RegularQuery =
  RegularQuery {
    regularQueryHead :: SingleQuery,
    regularQueryRest :: [Union]}
  deriving (Eq, Ord, Read, Show)

_RegularQuery = Core.Name "hydra.cypher.openCypher.RegularQuery"

_RegularQuery_head = Core.Name "head"

_RegularQuery_rest = Core.Name "rest"

data Union =
  Union {
    unionAll :: Bool,
    unionQuery :: SingleQuery}
  deriving (Eq, Ord, Read, Show)

_Union = Core.Name "hydra.cypher.openCypher.Union"

_Union_all = Core.Name "all"

_Union_query = Core.Name "query"

data SingleQuery =
  SingleQuerySinglePart SinglePartQuery |
  SingleQueryMultiPart MultiPartQuery
  deriving (Eq, Ord, Read, Show)

_SingleQuery = Core.Name "hydra.cypher.openCypher.SingleQuery"

_SingleQuery_singlePart = Core.Name "singlePart"

_SingleQuery_multiPart = Core.Name "multiPart"

data SinglePartQuery =
  SinglePartQuery {
    singlePartQueryReading :: [ReadingClause],
    singlePartQueryUpdating :: [UpdatingClause],
    singlePartQueryReturn :: (Maybe Return)}
  deriving (Eq, Ord, Read, Show)

_SinglePartQuery = Core.Name "hydra.cypher.openCypher.SinglePartQuery"

_SinglePartQuery_reading = Core.Name "reading"

_SinglePartQuery_updating = Core.Name "updating"

_SinglePartQuery_return = Core.Name "return"

data WithClause =
  WithClause {
    withClauseReading :: [ReadingClause],
    withClauseUpdating :: [UpdatingClause],
    withClauseWith :: With}
  deriving (Eq, Ord, Read, Show)

_WithClause = Core.Name "hydra.cypher.openCypher.WithClause"

_WithClause_reading = Core.Name "reading"

_WithClause_updating = Core.Name "updating"

_WithClause_with = Core.Name "with"

data MultiPartQuery =
  MultiPartQuery {
    multiPartQueryWith :: [WithClause],
    multiPartQueryBody :: SinglePartQuery}
  deriving (Eq, Ord, Read, Show)

_MultiPartQuery = Core.Name "hydra.cypher.openCypher.MultiPartQuery"

_MultiPartQuery_with = Core.Name "with"

_MultiPartQuery_body = Core.Name "body"

data UpdatingClause =
  UpdatingClauseCreate Create |
  UpdatingClauseMerge Merge |
  UpdatingClauseDelete Delete |
  UpdatingClauseSet Set |
  UpdatingClauseRemove Remove
  deriving (Eq, Ord, Read, Show)

_UpdatingClause = Core.Name "hydra.cypher.openCypher.UpdatingClause"

_UpdatingClause_create = Core.Name "create"

_UpdatingClause_merge = Core.Name "merge"

_UpdatingClause_delete = Core.Name "delete"

_UpdatingClause_set = Core.Name "set"

_UpdatingClause_remove = Core.Name "remove"

data ReadingClause =
  ReadingClauseMatch Match |
  ReadingClauseUnwind Unwind |
  ReadingClauseInQueryCall InQueryCall
  deriving (Eq, Ord, Read, Show)

_ReadingClause = Core.Name "hydra.cypher.openCypher.ReadingClause"

_ReadingClause_match = Core.Name "match"

_ReadingClause_unwind = Core.Name "unwind"

_ReadingClause_inQueryCall = Core.Name "inQueryCall"

data Match =
  Match {
    matchOptional :: Bool,
    matchPattern :: Pattern,
    matchWhere :: (Maybe Where)}
  deriving (Eq, Ord, Read, Show)

_Match = Core.Name "hydra.cypher.openCypher.Match"

_Match_optional = Core.Name "optional"

_Match_pattern = Core.Name "pattern"

_Match_where = Core.Name "where"

data Unwind =
  Unwind {
    unwindExpression :: Expression,
    unwindVariable :: Variable}
  deriving (Eq, Ord, Read, Show)

_Unwind = Core.Name "hydra.cypher.openCypher.Unwind"

_Unwind_expression = Core.Name "expression"

_Unwind_variable = Core.Name "variable"

data Merge =
  Merge {
    mergePatternPart :: PatternPart,
    mergeActions :: [MergeAction]}
  deriving (Eq, Ord, Read, Show)

_Merge = Core.Name "hydra.cypher.openCypher.Merge"

_Merge_patternPart = Core.Name "patternPart"

_Merge_actions = Core.Name "actions"

data MatchOrCreate =
  MatchOrCreateMatch  |
  MatchOrCreateCreate
  deriving (Eq, Ord, Read, Show)

_MatchOrCreate = Core.Name "hydra.cypher.openCypher.MatchOrCreate"

_MatchOrCreate_match = Core.Name "match"

_MatchOrCreate_create = Core.Name "create"

data MergeAction =
  MergeAction {
    mergeActionAction :: MatchOrCreate,
    mergeActionSet :: Set}
  deriving (Eq, Ord, Read, Show)

_MergeAction = Core.Name "hydra.cypher.openCypher.MergeAction"

_MergeAction_action = Core.Name "action"

_MergeAction_set = Core.Name "set"

newtype Create =
  Create {
    unCreate :: Pattern}
  deriving (Eq, Ord, Read, Show)

_Create = Core.Name "hydra.cypher.openCypher.Create"

newtype Set =
  Set {
    unSet :: [SetItem]}
  deriving (Eq, Ord, Read, Show)

_Set = Core.Name "hydra.cypher.openCypher.Set"

data SetItem =
  SetItemProperty PropertyEquals |
  SetItemVariableEqual VariableEquals |
  SetItemVariablePlusEqual VariablePlusEquals |
  SetItemVariableLabels VariableAndNodeLabels
  deriving (Eq, Ord, Read, Show)

_SetItem = Core.Name "hydra.cypher.openCypher.SetItem"

_SetItem_property = Core.Name "property"

_SetItem_variableEqual = Core.Name "variableEqual"

_SetItem_variablePlusEqual = Core.Name "variablePlusEqual"

_SetItem_variableLabels = Core.Name "variableLabels"

data PropertyEquals =
  PropertyEquals {
    propertyEqualsLhs :: PropertyExpression,
    propertyEqualsRhs :: Expression}
  deriving (Eq, Ord, Read, Show)

_PropertyEquals = Core.Name "hydra.cypher.openCypher.PropertyEquals"

_PropertyEquals_lhs = Core.Name "lhs"

_PropertyEquals_rhs = Core.Name "rhs"

data VariableEquals =
  VariableEquals {
    variableEqualsLhs :: Variable,
    variableEqualsRhs :: Expression}
  deriving (Eq, Ord, Read, Show)

_VariableEquals = Core.Name "hydra.cypher.openCypher.VariableEquals"

_VariableEquals_lhs = Core.Name "lhs"

_VariableEquals_rhs = Core.Name "rhs"

data VariablePlusEquals =
  VariablePlusEquals {
    variablePlusEqualsLhs :: Variable,
    variablePlusEqualsRhs :: Expression}
  deriving (Eq, Ord, Read, Show)

_VariablePlusEquals = Core.Name "hydra.cypher.openCypher.VariablePlusEquals"

_VariablePlusEquals_lhs = Core.Name "lhs"

_VariablePlusEquals_rhs = Core.Name "rhs"

data VariableAndNodeLabels =
  VariableAndNodeLabels {
    variableAndNodeLabelsVariable :: Variable,
    variableAndNodeLabelsLabels :: NodeLabels}
  deriving (Eq, Ord, Read, Show)

_VariableAndNodeLabels = Core.Name "hydra.cypher.openCypher.VariableAndNodeLabels"

_VariableAndNodeLabels_variable = Core.Name "variable"

_VariableAndNodeLabels_labels = Core.Name "labels"

data Delete =
  Delete {
    deleteDetach :: Bool,
    deleteExpressions :: [Expression]}
  deriving (Eq, Ord, Read, Show)

_Delete = Core.Name "hydra.cypher.openCypher.Delete"

_Delete_detach = Core.Name "detach"

_Delete_expressions = Core.Name "expressions"

newtype Remove =
  Remove {
    unRemove :: [RemoveItem]}
  deriving (Eq, Ord, Read, Show)

_Remove = Core.Name "hydra.cypher.openCypher.Remove"

data RemoveItem =
  RemoveItemVariableLabels VariableAndNodeLabels |
  RemoveItemProperty PropertyExpression
  deriving (Eq, Ord, Read, Show)

_RemoveItem = Core.Name "hydra.cypher.openCypher.RemoveItem"

_RemoveItem_variableLabels = Core.Name "variableLabels"

_RemoveItem_property = Core.Name "property"

data InQueryCall =
  InQueryCall {
    inQueryCallCall :: ExplicitProcedureInvocation,
    inQueryCallYieldItems :: (Maybe YieldItems)}
  deriving (Eq, Ord, Read, Show)

_InQueryCall = Core.Name "hydra.cypher.openCypher.InQueryCall"

_InQueryCall_call = Core.Name "call"

_InQueryCall_yieldItems = Core.Name "yieldItems"

data ProcedureInvocation =
  ProcedureInvocationExplicit ExplicitProcedureInvocation |
  ProcedureInvocationImplicit ImplicitProcedureInvocation
  deriving (Eq, Ord, Read, Show)

_ProcedureInvocation = Core.Name "hydra.cypher.openCypher.ProcedureInvocation"

_ProcedureInvocation_explicit = Core.Name "explicit"

_ProcedureInvocation_implicit = Core.Name "implicit"

data StarOrYieldItems =
  StarOrYieldItemsStar  |
  StarOrYieldItemsItems YieldItems
  deriving (Eq, Ord, Read, Show)

_StarOrYieldItems = Core.Name "hydra.cypher.openCypher.StarOrYieldItems"

_StarOrYieldItems_star = Core.Name "star"

_StarOrYieldItems_items = Core.Name "items"

data StandaloneCall =
  StandaloneCall {
    standaloneCallCall :: ProcedureInvocation,
    standaloneCallYieldItems :: (Maybe StarOrYieldItems)}
  deriving (Eq, Ord, Read, Show)

_StandaloneCall = Core.Name "hydra.cypher.openCypher.StandaloneCall"

_StandaloneCall_call = Core.Name "call"

_StandaloneCall_yieldItems = Core.Name "yieldItems"

data YieldItems =
  YieldItems {
    yieldItemsItems :: [YieldItem],
    yieldItemsWhere :: (Maybe Where)}
  deriving (Eq, Ord, Read, Show)

_YieldItems = Core.Name "hydra.cypher.openCypher.YieldItems"

_YieldItems_items = Core.Name "items"

_YieldItems_where = Core.Name "where"

data YieldItem =
  YieldItem {
    yieldItemField :: (Maybe ProcedureResultField),
    yieldItemVariable :: Variable}
  deriving (Eq, Ord, Read, Show)

_YieldItem = Core.Name "hydra.cypher.openCypher.YieldItem"

_YieldItem_field = Core.Name "field"

_YieldItem_variable = Core.Name "variable"

data With =
  With {
    withProjection :: ProjectionBody,
    withWhere :: (Maybe Where)}
  deriving (Eq, Ord, Read, Show)

_With = Core.Name "hydra.cypher.openCypher.With"

_With_projection = Core.Name "projection"

_With_where = Core.Name "where"

newtype Return =
  Return {
    unReturn :: ProjectionBody}
  deriving (Eq, Ord, Read, Show)

_Return = Core.Name "hydra.cypher.openCypher.Return"

data ProjectionBody =
  ProjectionBody {
    projectionBodyDistinct :: Bool,
    projectionBodyProjectionItems :: ProjectionItems,
    projectionBodyOrder :: (Maybe Order),
    projectionBodySkip :: (Maybe Skip),
    projectionBodyLimit :: (Maybe Limit)}
  deriving (Eq, Ord, Read, Show)

_ProjectionBody = Core.Name "hydra.cypher.openCypher.ProjectionBody"

_ProjectionBody_distinct = Core.Name "distinct"

_ProjectionBody_projectionItems = Core.Name "projectionItems"

_ProjectionBody_order = Core.Name "order"

_ProjectionBody_skip = Core.Name "skip"

_ProjectionBody_limit = Core.Name "limit"

data ProjectionItems =
  ProjectionItems {
    projectionItemsStar :: Bool,
    projectionItemsExplicit :: [ProjectionItem]}
  deriving (Eq, Ord, Read, Show)

_ProjectionItems = Core.Name "hydra.cypher.openCypher.ProjectionItems"

_ProjectionItems_star = Core.Name "star"

_ProjectionItems_explicit = Core.Name "explicit"

data ProjectionItem =
  ProjectionItem {
    projectionItemExpression :: Expression,
    projectionItemVariable :: (Maybe Variable)}
  deriving (Eq, Ord, Read, Show)

_ProjectionItem = Core.Name "hydra.cypher.openCypher.ProjectionItem"

_ProjectionItem_expression = Core.Name "expression"

_ProjectionItem_variable = Core.Name "variable"

newtype Order =
  Order {
    unOrder :: [SortItem]}
  deriving (Eq, Ord, Read, Show)

_Order = Core.Name "hydra.cypher.openCypher.Order"

newtype Skip =
  Skip {
    unSkip :: Expression}
  deriving (Eq, Ord, Read, Show)

_Skip = Core.Name "hydra.cypher.openCypher.Skip"

newtype Limit =
  Limit {
    unLimit :: Expression}
  deriving (Eq, Ord, Read, Show)

_Limit = Core.Name "hydra.cypher.openCypher.Limit"

data SortOrder =
  SortOrderAscending  |
  SortOrderDescending
  deriving (Eq, Ord, Read, Show)

_SortOrder = Core.Name "hydra.cypher.openCypher.SortOrder"

_SortOrder_ascending = Core.Name "ascending"

_SortOrder_descending = Core.Name "descending"

data SortItem =
  SortItem {
    sortItemExpression :: Expression,
    sortItemOrder :: (Maybe SortOrder)}
  deriving (Eq, Ord, Read, Show)

_SortItem = Core.Name "hydra.cypher.openCypher.SortItem"

_SortItem_expression = Core.Name "expression"

_SortItem_order = Core.Name "order"

newtype Where =
  Where {
    unWhere :: Expression}
  deriving (Eq, Ord, Read, Show)

_Where = Core.Name "hydra.cypher.openCypher.Where"

newtype Pattern =
  Pattern {
    unPattern :: [PatternPart]}
  deriving (Eq, Ord, Read, Show)

_Pattern = Core.Name "hydra.cypher.openCypher.Pattern"

data PatternPart =
  PatternPart {
    patternPartVariable :: (Maybe Variable),
    patternPartPattern :: AnonymousPatternPart}
  deriving (Eq, Ord, Read, Show)

_PatternPart = Core.Name "hydra.cypher.openCypher.PatternPart"

_PatternPart_variable = Core.Name "variable"

_PatternPart_pattern = Core.Name "pattern"

newtype AnonymousPatternPart =
  AnonymousPatternPart {
    unAnonymousPatternPart :: PatternElement}
  deriving (Eq, Ord, Read, Show)

_AnonymousPatternPart = Core.Name "hydra.cypher.openCypher.AnonymousPatternPart"

data NodePatternChain =
  NodePatternChain {
    nodePatternChainNodePattern :: NodePattern,
    nodePatternChainChain :: [PatternElementChain]}
  deriving (Eq, Ord, Read, Show)

_NodePatternChain = Core.Name "hydra.cypher.openCypher.NodePatternChain"

_NodePatternChain_nodePattern = Core.Name "nodePattern"

_NodePatternChain_chain = Core.Name "chain"

data PatternElement =
  PatternElementChained NodePatternChain |
  PatternElementParenthesized PatternElement
  deriving (Eq, Ord, Read, Show)

_PatternElement = Core.Name "hydra.cypher.openCypher.PatternElement"

_PatternElement_chained = Core.Name "chained"

_PatternElement_parenthesized = Core.Name "parenthesized"

data RelationshipsPattern =
  RelationshipsPattern {
    relationshipsPatternNodePattern :: NodePattern,
    relationshipsPatternChain :: [PatternElementChain]}
  deriving (Eq, Ord, Read, Show)

_RelationshipsPattern = Core.Name "hydra.cypher.openCypher.RelationshipsPattern"

_RelationshipsPattern_nodePattern = Core.Name "nodePattern"

_RelationshipsPattern_chain = Core.Name "chain"

data NodePattern =
  NodePattern {
    nodePatternVariable :: (Maybe Variable),
    nodePatternLabels :: (Maybe NodeLabels),
    nodePatternProperties :: (Maybe Properties)}
  deriving (Eq, Ord, Read, Show)

_NodePattern = Core.Name "hydra.cypher.openCypher.NodePattern"

_NodePattern_variable = Core.Name "variable"

_NodePattern_labels = Core.Name "labels"

_NodePattern_properties = Core.Name "properties"

data PatternElementChain =
  PatternElementChain {
    patternElementChainRelationship :: RelationshipPattern,
    patternElementChainNode :: NodePattern}
  deriving (Eq, Ord, Read, Show)

_PatternElementChain = Core.Name "hydra.cypher.openCypher.PatternElementChain"

_PatternElementChain_relationship = Core.Name "relationship"

_PatternElementChain_node = Core.Name "node"

data RelationshipPattern =
  RelationshipPattern {
    relationshipPatternLeftArrow :: Bool,
    relationshipPatternDetail :: (Maybe RelationshipDetail),
    relationshipPatternRightArrow :: Bool}
  deriving (Eq, Ord, Read, Show)

_RelationshipPattern = Core.Name "hydra.cypher.openCypher.RelationshipPattern"

_RelationshipPattern_leftArrow = Core.Name "leftArrow"

_RelationshipPattern_detail = Core.Name "detail"

_RelationshipPattern_rightArrow = Core.Name "rightArrow"

data RelationshipDetail =
  RelationshipDetail {
    relationshipDetailVariable :: (Maybe Variable),
    relationshipDetailTypes :: (Maybe RelationshipTypes),
    relationshipDetailRange :: (Maybe RangeLiteral),
    relationshipDetailProperties :: (Maybe Properties)}
  deriving (Eq, Ord, Read, Show)

_RelationshipDetail = Core.Name "hydra.cypher.openCypher.RelationshipDetail"

_RelationshipDetail_variable = Core.Name "variable"

_RelationshipDetail_types = Core.Name "types"

_RelationshipDetail_range = Core.Name "range"

_RelationshipDetail_properties = Core.Name "properties"

data Properties =
  PropertiesMap MapLiteral |
  PropertiesParameter Parameter
  deriving (Eq, Ord, Read, Show)

_Properties = Core.Name "hydra.cypher.openCypher.Properties"

_Properties_map = Core.Name "map"

_Properties_parameter = Core.Name "parameter"

newtype RelationshipTypes =
  RelationshipTypes {
    unRelationshipTypes :: [RelTypeName]}
  deriving (Eq, Ord, Read, Show)

_RelationshipTypes = Core.Name "hydra.cypher.openCypher.RelationshipTypes"

newtype NodeLabels =
  NodeLabels {
    unNodeLabels :: [NodeLabel]}
  deriving (Eq, Ord, Read, Show)

_NodeLabels = Core.Name "hydra.cypher.openCypher.NodeLabels"

newtype NodeLabel =
  NodeLabel {
    unNodeLabel :: String}
  deriving (Eq, Ord, Read, Show)

_NodeLabel = Core.Name "hydra.cypher.openCypher.NodeLabel"

data RangeLiteral =
  RangeLiteral {
    rangeLiteralStart :: (Maybe Integer),
    rangeLiteralEnd :: (Maybe Integer)}
  deriving (Eq, Ord, Read, Show)

_RangeLiteral = Core.Name "hydra.cypher.openCypher.RangeLiteral"

_RangeLiteral_start = Core.Name "start"

_RangeLiteral_end = Core.Name "end"

newtype RelTypeName =
  RelTypeName {
    unRelTypeName :: String}
  deriving (Eq, Ord, Read, Show)

_RelTypeName = Core.Name "hydra.cypher.openCypher.RelTypeName"

data PropertyExpression =
  PropertyExpression {
    propertyExpressionAtom :: Atom,
    propertyExpressionLookups :: [PropertyLookup]}
  deriving (Eq, Ord, Read, Show)

_PropertyExpression = Core.Name "hydra.cypher.openCypher.PropertyExpression"

_PropertyExpression_atom = Core.Name "atom"

_PropertyExpression_lookups = Core.Name "lookups"

newtype Expression =
  Expression {
    unExpression :: OrExpression}
  deriving (Eq, Ord, Read, Show)

_Expression = Core.Name "hydra.cypher.openCypher.Expression"

newtype OrExpression =
  OrExpression {
    unOrExpression :: [XorExpression]}
  deriving (Eq, Ord, Read, Show)

_OrExpression = Core.Name "hydra.cypher.openCypher.OrExpression"

newtype XorExpression =
  XorExpression {
    unXorExpression :: [AndExpression]}
  deriving (Eq, Ord, Read, Show)

_XorExpression = Core.Name "hydra.cypher.openCypher.XorExpression"

newtype AndExpression =
  AndExpression {
    unAndExpression :: [NotExpression]}
  deriving (Eq, Ord, Read, Show)

_AndExpression = Core.Name "hydra.cypher.openCypher.AndExpression"

data NotExpression =
  NotExpression {
    notExpressionNot :: Bool,
    notExpressionExpression :: ComparisonExpression}
  deriving (Eq, Ord, Read, Show)

_NotExpression = Core.Name "hydra.cypher.openCypher.NotExpression"

_NotExpression_not = Core.Name "not"

_NotExpression_expression = Core.Name "expression"

data ComparisonExpression =
  ComparisonExpression {
    comparisonExpressionLeft :: StringListNullPredicateExpression,
    comparisonExpressionRight :: [PartialComparisonExpression]}
  deriving (Eq, Ord, Read, Show)

_ComparisonExpression = Core.Name "hydra.cypher.openCypher.ComparisonExpression"

_ComparisonExpression_left = Core.Name "left"

_ComparisonExpression_right = Core.Name "right"

data ComparisonOperator =
  ComparisonOperatorEq  |
  ComparisonOperatorNeq  |
  ComparisonOperatorLt  |
  ComparisonOperatorGt  |
  ComparisonOperatorLte  |
  ComparisonOperatorGte
  deriving (Eq, Ord, Read, Show)

_ComparisonOperator = Core.Name "hydra.cypher.openCypher.ComparisonOperator"

_ComparisonOperator_eq = Core.Name "eq"

_ComparisonOperator_neq = Core.Name "neq"

_ComparisonOperator_lt = Core.Name "lt"

_ComparisonOperator_gt = Core.Name "gt"

_ComparisonOperator_lte = Core.Name "lte"

_ComparisonOperator_gte = Core.Name "gte"

data PartialComparisonExpression =
  PartialComparisonExpression {
    partialComparisonExpressionOperator :: ComparisonOperator,
    partialComparisonExpressionRight :: StringListNullPredicateExpression}
  deriving (Eq, Ord, Read, Show)

_PartialComparisonExpression = Core.Name "hydra.cypher.openCypher.PartialComparisonExpression"

_PartialComparisonExpression_operator = Core.Name "operator"

_PartialComparisonExpression_right = Core.Name "right"

data StringListNullPredicateExpression =
  StringListNullPredicateExpression {
    stringListNullPredicateExpressionLeft :: AddOrSubtractExpression,
    stringListNullPredicateExpressionRight :: [StringListNullPredicateRightHandSide]}
  deriving (Eq, Ord, Read, Show)

_StringListNullPredicateExpression = Core.Name "hydra.cypher.openCypher.StringListNullPredicateExpression"

_StringListNullPredicateExpression_left = Core.Name "left"

_StringListNullPredicateExpression_right = Core.Name "right"

data StringListNullPredicateRightHandSide =
  StringListNullPredicateRightHandSideString StringPredicateExpression |
  StringListNullPredicateRightHandSideList ListPredicateExpression |
  StringListNullPredicateRightHandSideNull NullPredicateExpression
  deriving (Eq, Ord, Read, Show)

_StringListNullPredicateRightHandSide = Core.Name "hydra.cypher.openCypher.StringListNullPredicateRightHandSide"

_StringListNullPredicateRightHandSide_string = Core.Name "string"

_StringListNullPredicateRightHandSide_list = Core.Name "list"

_StringListNullPredicateRightHandSide_null = Core.Name "null"

data StringPredicateExpression =
  StringPredicateExpression {
    stringPredicateExpressionOperator :: StringPredicateOperator,
    stringPredicateExpressionExpression :: AddOrSubtractExpression}
  deriving (Eq, Ord, Read, Show)

_StringPredicateExpression = Core.Name "hydra.cypher.openCypher.StringPredicateExpression"

_StringPredicateExpression_operator = Core.Name "operator"

_StringPredicateExpression_expression = Core.Name "expression"

data StringPredicateOperator =
  StringPredicateOperatorStartsWith  |
  StringPredicateOperatorEndsWith  |
  StringPredicateOperatorContains
  deriving (Eq, Ord, Read, Show)

_StringPredicateOperator = Core.Name "hydra.cypher.openCypher.StringPredicateOperator"

_StringPredicateOperator_startsWith = Core.Name "startsWith"

_StringPredicateOperator_endsWith = Core.Name "endsWith"

_StringPredicateOperator_contains = Core.Name "contains"

newtype ListPredicateExpression =
  ListPredicateExpression {
    unListPredicateExpression :: AddOrSubtractExpression}
  deriving (Eq, Ord, Read, Show)

_ListPredicateExpression = Core.Name "hydra.cypher.openCypher.ListPredicateExpression"

newtype NullPredicateExpression =
  NullPredicateExpression {
    unNullPredicateExpression :: Bool}
  deriving (Eq, Ord, Read, Show)

_NullPredicateExpression = Core.Name "hydra.cypher.openCypher.NullPredicateExpression"

data AddOrSubtractExpression =
  AddOrSubtractExpression {
    addOrSubtractExpressionLeft :: MultiplyDivideModuloExpression,
    addOrSubtractExpressionRight :: [AddOrSubtractRightHandSide]}
  deriving (Eq, Ord, Read, Show)

_AddOrSubtractExpression = Core.Name "hydra.cypher.openCypher.AddOrSubtractExpression"

_AddOrSubtractExpression_left = Core.Name "left"

_AddOrSubtractExpression_right = Core.Name "right"

data AddOrSubtractRightHandSide =
  AddOrSubtractRightHandSide {
    addOrSubtractRightHandSideOperator :: AddOrSubtractOperator,
    addOrSubtractRightHandSideExpression :: MultiplyDivideModuloExpression}
  deriving (Eq, Ord, Read, Show)

_AddOrSubtractRightHandSide = Core.Name "hydra.cypher.openCypher.AddOrSubtractRightHandSide"

_AddOrSubtractRightHandSide_operator = Core.Name "operator"

_AddOrSubtractRightHandSide_expression = Core.Name "expression"

data AddOrSubtractOperator =
  AddOrSubtractOperatorAdd  |
  AddOrSubtractOperatorSubtract
  deriving (Eq, Ord, Read, Show)

_AddOrSubtractOperator = Core.Name "hydra.cypher.openCypher.AddOrSubtractOperator"

_AddOrSubtractOperator_add = Core.Name "add"

_AddOrSubtractOperator_subtract = Core.Name "subtract"

data MultiplyDivideModuloExpression =
  MultiplyDivideModuloExpression {
    multiplyDivideModuloExpressionLeft :: PowerOfExpression,
    multiplyDivideModuloExpressionRight :: [MultiplyDivideModuloRightHandSide]}
  deriving (Eq, Ord, Read, Show)

_MultiplyDivideModuloExpression = Core.Name "hydra.cypher.openCypher.MultiplyDivideModuloExpression"

_MultiplyDivideModuloExpression_left = Core.Name "left"

_MultiplyDivideModuloExpression_right = Core.Name "right"

data MultiplyDivideModuloRightHandSide =
  MultiplyDivideModuloRightHandSide {
    multiplyDivideModuloRightHandSideOperator :: MultiplyDivideModuloOperator,
    multiplyDivideModuloRightHandSideExpression :: PowerOfExpression}
  deriving (Eq, Ord, Read, Show)

_MultiplyDivideModuloRightHandSide = Core.Name "hydra.cypher.openCypher.MultiplyDivideModuloRightHandSide"

_MultiplyDivideModuloRightHandSide_operator = Core.Name "operator"

_MultiplyDivideModuloRightHandSide_expression = Core.Name "expression"

data MultiplyDivideModuloOperator =
  MultiplyDivideModuloOperatorMultiply  |
  MultiplyDivideModuloOperatorDivide  |
  MultiplyDivideModuloOperatorModulo
  deriving (Eq, Ord, Read, Show)

_MultiplyDivideModuloOperator = Core.Name "hydra.cypher.openCypher.MultiplyDivideModuloOperator"

_MultiplyDivideModuloOperator_multiply = Core.Name "multiply"

_MultiplyDivideModuloOperator_divide = Core.Name "divide"

_MultiplyDivideModuloOperator_modulo = Core.Name "modulo"

newtype PowerOfExpression =
  PowerOfExpression {
    unPowerOfExpression :: [UnaryAddOrSubtractExpression]}
  deriving (Eq, Ord, Read, Show)

_PowerOfExpression = Core.Name "hydra.cypher.openCypher.PowerOfExpression"

data UnaryAddOrSubtractExpression =
  UnaryAddOrSubtractExpression {
    unaryAddOrSubtractExpressionOperator :: (Maybe AddOrSubtractOperator),
    unaryAddOrSubtractExpressionExpression :: NonArithmeticOperatorExpression}
  deriving (Eq, Ord, Read, Show)

_UnaryAddOrSubtractExpression = Core.Name "hydra.cypher.openCypher.UnaryAddOrSubtractExpression"

_UnaryAddOrSubtractExpression_operator = Core.Name "operator"

_UnaryAddOrSubtractExpression_expression = Core.Name "expression"

data ListOperatorExpressionOrPropertyLookup =
  ListOperatorExpressionOrPropertyLookupList ListOperatorExpression |
  ListOperatorExpressionOrPropertyLookupProperty PropertyLookup
  deriving (Eq, Ord, Read, Show)

_ListOperatorExpressionOrPropertyLookup = Core.Name "hydra.cypher.openCypher.ListOperatorExpressionOrPropertyLookup"

_ListOperatorExpressionOrPropertyLookup_list = Core.Name "list"

_ListOperatorExpressionOrPropertyLookup_property = Core.Name "property"

data NonArithmeticOperatorExpression =
  NonArithmeticOperatorExpression {
    nonArithmeticOperatorExpressionAtom :: Atom,
    nonArithmeticOperatorExpressionListsAndLookups :: [ListOperatorExpressionOrPropertyLookup],
    nonArithmeticOperatorExpressionLabels :: (Maybe NodeLabels)}
  deriving (Eq, Ord, Read, Show)

_NonArithmeticOperatorExpression = Core.Name "hydra.cypher.openCypher.NonArithmeticOperatorExpression"

_NonArithmeticOperatorExpression_atom = Core.Name "atom"

_NonArithmeticOperatorExpression_listsAndLookups = Core.Name "listsAndLookups"

_NonArithmeticOperatorExpression_labels = Core.Name "labels"

data RangeExpression =
  RangeExpression {
    rangeExpressionStart :: (Maybe Expression),
    rangeExpressionEnd :: (Maybe Expression)}
  deriving (Eq, Ord, Read, Show)

_RangeExpression = Core.Name "hydra.cypher.openCypher.RangeExpression"

_RangeExpression_start = Core.Name "start"

_RangeExpression_end = Core.Name "end"

data ListOperatorExpression =
  ListOperatorExpressionSingle Expression |
  ListOperatorExpressionRange RangeExpression
  deriving (Eq, Ord, Read, Show)

_ListOperatorExpression = Core.Name "hydra.cypher.openCypher.ListOperatorExpression"

_ListOperatorExpression_single = Core.Name "single"

_ListOperatorExpression_range = Core.Name "range"

newtype PropertyLookup =
  PropertyLookup {
    unPropertyLookup :: PropertyKeyName}
  deriving (Eq, Ord, Read, Show)

_PropertyLookup = Core.Name "hydra.cypher.openCypher.PropertyLookup"

data Atom =
  AtomLiteral Literal |
  AtomParameter Parameter |
  AtomCase CaseExpression |
  AtomCountStar  |
  AtomListComprehension ListComprehension |
  AtomPatternComprehension PatternComprehension |
  AtomQuantifier Quantifier |
  AtomPatternPredicate PatternPredicate |
  AtomParenthesized ParenthesizedExpression |
  AtomFunctionInvocation FunctionInvocation |
  AtomExistentialSubquery ExistentialSubquery |
  AtomVariable Variable
  deriving (Eq, Ord, Read, Show)

_Atom = Core.Name "hydra.cypher.openCypher.Atom"

_Atom_literal = Core.Name "literal"

_Atom_parameter = Core.Name "parameter"

_Atom_case = Core.Name "case"

_Atom_countStar = Core.Name "countStar"

_Atom_listComprehension = Core.Name "listComprehension"

_Atom_patternComprehension = Core.Name "patternComprehension"

_Atom_quantifier = Core.Name "quantifier"

_Atom_patternPredicate = Core.Name "patternPredicate"

_Atom_parenthesized = Core.Name "parenthesized"

_Atom_functionInvocation = Core.Name "functionInvocation"

_Atom_existentialSubquery = Core.Name "existentialSubquery"

_Atom_variable = Core.Name "variable"

data CaseExpression =
  CaseExpression {
    caseExpressionExpression :: (Maybe Expression),
    caseExpressionAlternatives :: [CaseAlternative],
    caseExpressionElse :: (Maybe Expression)}
  deriving (Eq, Ord, Read, Show)

_CaseExpression = Core.Name "hydra.cypher.openCypher.CaseExpression"

_CaseExpression_expression = Core.Name "expression"

_CaseExpression_alternatives = Core.Name "alternatives"

_CaseExpression_else = Core.Name "else"

data CaseAlternative =
  CaseAlternative {
    caseAlternativeCondition :: Expression,
    caseAlternativeResult :: Expression}
  deriving (Eq, Ord, Read, Show)

_CaseAlternative = Core.Name "hydra.cypher.openCypher.CaseAlternative"

_CaseAlternative_condition = Core.Name "condition"

_CaseAlternative_result = Core.Name "result"

data ListComprehension =
  ListComprehension {
    listComprehensionLeft :: FilterExpression,
    listComprehensionRight :: (Maybe Expression)}
  deriving (Eq, Ord, Read, Show)

_ListComprehension = Core.Name "hydra.cypher.openCypher.ListComprehension"

_ListComprehension_left = Core.Name "left"

_ListComprehension_right = Core.Name "right"

data PatternComprehension =
  PatternComprehension {
    patternComprehensionVariable :: (Maybe Variable),
    patternComprehensionPattern :: RelationshipsPattern,
    patternComprehensionWhere :: (Maybe Where),
    patternComprehensionRight :: Expression}
  deriving (Eq, Ord, Read, Show)

_PatternComprehension = Core.Name "hydra.cypher.openCypher.PatternComprehension"

_PatternComprehension_variable = Core.Name "variable"

_PatternComprehension_pattern = Core.Name "pattern"

_PatternComprehension_where = Core.Name "where"

_PatternComprehension_right = Core.Name "right"

data Quantifier =
  Quantifier {
    quantifierOperator :: QuantifierOperator,
    quantifierExpression :: FilterExpression}
  deriving (Eq, Ord, Read, Show)

_Quantifier = Core.Name "hydra.cypher.openCypher.Quantifier"

_Quantifier_operator = Core.Name "operator"

_Quantifier_expression = Core.Name "expression"

data QuantifierOperator =
  QuantifierOperatorAll  |
  QuantifierOperatorAny  |
  QuantifierOperatorNone  |
  QuantifierOperatorSingle
  deriving (Eq, Ord, Read, Show)

_QuantifierOperator = Core.Name "hydra.cypher.openCypher.QuantifierOperator"

_QuantifierOperator_all = Core.Name "all"

_QuantifierOperator_any = Core.Name "any"

_QuantifierOperator_none = Core.Name "none"

_QuantifierOperator_single = Core.Name "single"

data FilterExpression =
  FilterExpression {
    filterExpressionIdInColl :: IdInColl,
    filterExpressionWhere :: (Maybe Where)}
  deriving (Eq, Ord, Read, Show)

_FilterExpression = Core.Name "hydra.cypher.openCypher.FilterExpression"

_FilterExpression_idInColl = Core.Name "idInColl"

_FilterExpression_where = Core.Name "where"

newtype PatternPredicate =
  PatternPredicate {
    unPatternPredicate :: RelationshipsPattern}
  deriving (Eq, Ord, Read, Show)

_PatternPredicate = Core.Name "hydra.cypher.openCypher.PatternPredicate"

newtype ParenthesizedExpression =
  ParenthesizedExpression {
    unParenthesizedExpression :: Expression}
  deriving (Eq, Ord, Read, Show)

_ParenthesizedExpression = Core.Name "hydra.cypher.openCypher.ParenthesizedExpression"

data IdInColl =
  IdInColl {
    idInCollVariable :: Variable,
    idInCollExpression :: Expression}
  deriving (Eq, Ord, Read, Show)

_IdInColl = Core.Name "hydra.cypher.openCypher.IdInColl"

_IdInColl_variable = Core.Name "variable"

_IdInColl_expression = Core.Name "expression"

data FunctionInvocation =
  FunctionInvocation {
    functionInvocationName :: QualifiedName,
    functionInvocationDistinct :: Bool,
    functionInvocationArguments :: [Expression]}
  deriving (Eq, Ord, Read, Show)

_FunctionInvocation = Core.Name "hydra.cypher.openCypher.FunctionInvocation"

_FunctionInvocation_name = Core.Name "name"

_FunctionInvocation_distinct = Core.Name "distinct"

_FunctionInvocation_arguments = Core.Name "arguments"

data QualifiedName =
  QualifiedName {
    qualifiedNameNamespace :: String,
    qualifiedNameLocal :: String}
  deriving (Eq, Ord, Read, Show)

_QualifiedName = Core.Name "hydra.cypher.openCypher.QualifiedName"

_QualifiedName_namespace = Core.Name "namespace"

_QualifiedName_local = Core.Name "local"

data PatternWhere =
  PatternWhere {
    patternWherePattern :: Pattern,
    patternWhereWhere :: (Maybe Where)}
  deriving (Eq, Ord, Read, Show)

_PatternWhere = Core.Name "hydra.cypher.openCypher.PatternWhere"

_PatternWhere_pattern = Core.Name "pattern"

_PatternWhere_where = Core.Name "where"

data ExistentialSubquery =
  ExistentialSubqueryRegular RegularQuery |
  ExistentialSubqueryPattern PatternWhere
  deriving (Eq, Ord, Read, Show)

_ExistentialSubquery = Core.Name "hydra.cypher.openCypher.ExistentialSubquery"

_ExistentialSubquery_regular = Core.Name "regular"

_ExistentialSubquery_pattern = Core.Name "pattern"

data ExplicitProcedureInvocation =
  ExplicitProcedureInvocation {
    explicitProcedureInvocationName :: QualifiedName,
    explicitProcedureInvocationArguments :: [Expression]}
  deriving (Eq, Ord, Read, Show)

_ExplicitProcedureInvocation = Core.Name "hydra.cypher.openCypher.ExplicitProcedureInvocation"

_ExplicitProcedureInvocation_name = Core.Name "name"

_ExplicitProcedureInvocation_arguments = Core.Name "arguments"

newtype ImplicitProcedureInvocation =
  ImplicitProcedureInvocation {
    unImplicitProcedureInvocation :: QualifiedName}
  deriving (Eq, Ord, Read, Show)

_ImplicitProcedureInvocation = Core.Name "hydra.cypher.openCypher.ImplicitProcedureInvocation"

newtype ProcedureResultField =
  ProcedureResultField {
    unProcedureResultField :: String}
  deriving (Eq, Ord, Read, Show)

_ProcedureResultField = Core.Name "hydra.cypher.openCypher.ProcedureResultField"

newtype Variable =
  Variable {
    unVariable :: String}
  deriving (Eq, Ord, Read, Show)

_Variable = Core.Name "hydra.cypher.openCypher.Variable"

data Literal =
  LiteralBoolean Bool |
  LiteralNull  |
  LiteralNumber NumberLiteral |
  LiteralString StringLiteral |
  LiteralList ListLiteral |
  LiteralMap MapLiteral
  deriving (Eq, Ord, Read, Show)

_Literal = Core.Name "hydra.cypher.openCypher.Literal"

_Literal_boolean = Core.Name "boolean"

_Literal_null = Core.Name "null"

_Literal_number = Core.Name "number"

_Literal_string = Core.Name "string"

_Literal_list = Core.Name "list"

_Literal_map = Core.Name "map"

data NumberLiteral =
  NumberLiteralDouble Double |
  NumberLiteralInteger Integer
  deriving (Eq, Ord, Read, Show)

_NumberLiteral = Core.Name "hydra.cypher.openCypher.NumberLiteral"

_NumberLiteral_double = Core.Name "double"

_NumberLiteral_integer = Core.Name "integer"

newtype StringLiteral =
  StringLiteral {
    unStringLiteral :: String}
  deriving (Eq, Ord, Read, Show)

_StringLiteral = Core.Name "hydra.cypher.openCypher.StringLiteral"

newtype ListLiteral =
  ListLiteral {
    unListLiteral :: [Expression]}
  deriving (Eq, Ord, Read, Show)

_ListLiteral = Core.Name "hydra.cypher.openCypher.ListLiteral"

newtype MapLiteral =
  MapLiteral {
    unMapLiteral :: [KeyValuePair]}
  deriving (Eq, Ord, Read, Show)

_MapLiteral = Core.Name "hydra.cypher.openCypher.MapLiteral"

data KeyValuePair =
  KeyValuePair {
    keyValuePairKey :: PropertyKeyName,
    keyValuePairValue :: Expression}
  deriving (Eq, Ord, Read, Show)

_KeyValuePair = Core.Name "hydra.cypher.openCypher.KeyValuePair"

_KeyValuePair_key = Core.Name "key"

_KeyValuePair_value = Core.Name "value"

newtype PropertyKeyName =
  PropertyKeyName {
    unPropertyKeyName :: String}
  deriving (Eq, Ord, Read, Show)

_PropertyKeyName = Core.Name "hydra.cypher.openCypher.PropertyKeyName"

data Parameter =
  ParameterSymbolic String |
  ParameterInteger Integer
  deriving (Eq, Ord, Read, Show)

_Parameter = Core.Name "hydra.cypher.openCypher.Parameter"

_Parameter_symbolic = Core.Name "symbolic"

_Parameter_integer = Core.Name "integer"