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.Pg.Cypher.OpenCypher where

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

-- | An additive expression: a multiply/divide/modulo expression with zero or more +/- terms
data AddOrSubtractExpression =
  AddOrSubtractExpression {
    addOrSubtractExpressionLeft :: MultiplyDivideModuloExpression,
    addOrSubtractExpressionRight :: [AddOrSubtractRightHandSide]}
  deriving (Eq, Ord, Read, Show)

_AddOrSubtractExpression = Model.Name "hydra.pg.cypher.openCypher.AddOrSubtractExpression"

_AddOrSubtractExpression_left = Model.Name "left"

_AddOrSubtractExpression_right = Model.Name "right"

-- | An additive operator: + or -
data AddOrSubtractOperator =
  AddOrSubtractOperatorAdd |
  AddOrSubtractOperatorSubtract
  deriving (Eq, Ord, Read, Show)

_AddOrSubtractOperator = Model.Name "hydra.pg.cypher.openCypher.AddOrSubtractOperator"

_AddOrSubtractOperator_add = Model.Name "add"

_AddOrSubtractOperator_subtract = Model.Name "subtract"

-- | An additive operator applied to a right-hand multiply/divide/modulo expression
data AddOrSubtractRightHandSide =
  AddOrSubtractRightHandSide {
    addOrSubtractRightHandSideOperator :: AddOrSubtractOperator,
    addOrSubtractRightHandSideExpression :: MultiplyDivideModuloExpression}
  deriving (Eq, Ord, Read, Show)

_AddOrSubtractRightHandSide = Model.Name "hydra.pg.cypher.openCypher.AddOrSubtractRightHandSide"

_AddOrSubtractRightHandSide_operator = Model.Name "operator"

_AddOrSubtractRightHandSide_expression = Model.Name "expression"

-- | A conjunction of NOT expressions
newtype AndExpression =
  AndExpression {
    unAndExpression :: [NotExpression]}
  deriving (Eq, Ord, Read, Show)

_AndExpression = Model.Name "hydra.pg.cypher.openCypher.AndExpression"

-- | A pattern part with no bound path variable
newtype AnonymousPatternPart =
  AnonymousPatternPart {
    unAnonymousPatternPart :: PatternElement}
  deriving (Eq, Ord, Read, Show)

_AnonymousPatternPart = Model.Name "hydra.pg.cypher.openCypher.AnonymousPatternPart"

-- | An atomic expression: a literal, variable, parenthesized expression, or function-like construct
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 = Model.Name "hydra.pg.cypher.openCypher.Atom"

_Atom_literal = Model.Name "literal"

_Atom_parameter = Model.Name "parameter"

_Atom_case = Model.Name "case"

_Atom_countStar = Model.Name "countStar"

_Atom_listComprehension = Model.Name "listComprehension"

_Atom_patternComprehension = Model.Name "patternComprehension"

_Atom_quantifier = Model.Name "quantifier"

_Atom_patternPredicate = Model.Name "patternPredicate"

_Atom_parenthesized = Model.Name "parenthesized"

_Atom_functionInvocation = Model.Name "functionInvocation"

_Atom_existentialSubquery = Model.Name "existentialSubquery"

_Atom_variable = Model.Name "variable"

-- | One WHEN/THEN alternative of a CASE expression
data CaseAlternative =
  CaseAlternative {
    caseAlternativeCondition :: Expression,
    caseAlternativeResult :: Expression}
  deriving (Eq, Ord, Read, Show)

_CaseAlternative = Model.Name "hydra.pg.cypher.openCypher.CaseAlternative"

_CaseAlternative_condition = Model.Name "condition"

_CaseAlternative_result = Model.Name "result"

-- | A CASE expression, with an optional test and one or more alternatives
data CaseExpression =
  CaseExpression {
    caseExpressionExpression :: (Maybe Expression),
    caseExpressionAlternatives :: [CaseAlternative],
    caseExpressionElse :: (Maybe Expression)}
  deriving (Eq, Ord, Read, Show)

_CaseExpression = Model.Name "hydra.pg.cypher.openCypher.CaseExpression"

_CaseExpression_expression = Model.Name "expression"

_CaseExpression_alternatives = Model.Name "alternatives"

_CaseExpression_else = Model.Name "else"

-- | A comparison expression: an add/subtract expression with zero or more partial comparisons
data ComparisonExpression =
  ComparisonExpression {
    comparisonExpressionLeft :: StringListNullPredicateExpression,
    comparisonExpressionRight :: [PartialComparisonExpression]}
  deriving (Eq, Ord, Read, Show)

_ComparisonExpression = Model.Name "hydra.pg.cypher.openCypher.ComparisonExpression"

_ComparisonExpression_left = Model.Name "left"

_ComparisonExpression_right = Model.Name "right"

-- | A comparison operator: equality, inequality, or an ordering relation
data ComparisonOperator =
  ComparisonOperatorEq |
  ComparisonOperatorNeq |
  ComparisonOperatorLt |
  ComparisonOperatorGt |
  ComparisonOperatorLte |
  ComparisonOperatorGte
  deriving (Eq, Ord, Read, Show)

_ComparisonOperator = Model.Name "hydra.pg.cypher.openCypher.ComparisonOperator"

_ComparisonOperator_eq = Model.Name "eq"

_ComparisonOperator_neq = Model.Name "neq"

_ComparisonOperator_lt = Model.Name "lt"

_ComparisonOperator_gt = Model.Name "gt"

_ComparisonOperator_lte = Model.Name "lte"

_ComparisonOperator_gte = Model.Name "gte"

-- | A CREATE clause creating a pattern
newtype Create =
  Create {
    unCreate :: Pattern}
  deriving (Eq, Ord, Read, Show)

_Create = Model.Name "hydra.pg.cypher.openCypher.Create"

-- | A DELETE clause, optionally DETACH, removing nodes or relationships
data Delete =
  Delete {
    deleteDetach :: Bool,
    deleteExpressions :: [Expression]}
  deriving (Eq, Ord, Read, Show)

_Delete = Model.Name "hydra.pg.cypher.openCypher.Delete"

_Delete_detach = Model.Name "detach"

_Delete_expressions = Model.Name "expressions"

-- | An EXISTS subquery pattern with an optional WHERE clause
data ExistentialSubquery =
  ExistentialSubqueryRegular RegularQuery |
  ExistentialSubqueryPattern PatternWhere
  deriving (Eq, Ord, Read, Show)

_ExistentialSubquery = Model.Name "hydra.pg.cypher.openCypher.ExistentialSubquery"

_ExistentialSubquery_regular = Model.Name "regular"

_ExistentialSubquery_pattern = Model.Name "pattern"

-- | A procedure call with an explicit, parenthesized argument list
data ExplicitProcedureInvocation =
  ExplicitProcedureInvocation {
    explicitProcedureInvocationName :: QualifiedName,
    explicitProcedureInvocationArguments :: [Expression]}
  deriving (Eq, Ord, Read, Show)

_ExplicitProcedureInvocation = Model.Name "hydra.pg.cypher.openCypher.ExplicitProcedureInvocation"

_ExplicitProcedureInvocation_name = Model.Name "name"

_ExplicitProcedureInvocation_arguments = Model.Name "arguments"

-- | The top-level openCypher expression production: an OR expression
newtype Expression =
  Expression {
    unExpression :: OrExpression}
  deriving (Eq, Ord, Read, Show)

_Expression = Model.Name "hydra.pg.cypher.openCypher.Expression"

-- | An id-in-collection clause with an optional WHERE filter
data FilterExpression =
  FilterExpression {
    filterExpressionIdInColl :: IdInColl,
    filterExpressionWhere :: (Maybe Where)}
  deriving (Eq, Ord, Read, Show)

_FilterExpression = Model.Name "hydra.pg.cypher.openCypher.FilterExpression"

_FilterExpression_idInColl = Model.Name "idInColl"

_FilterExpression_where = Model.Name "where"

-- | A function call: a qualified name, an optional DISTINCT, and arguments
data FunctionInvocation =
  FunctionInvocation {
    functionInvocationName :: QualifiedName,
    functionInvocationDistinct :: Bool,
    functionInvocationArguments :: [Expression]}
  deriving (Eq, Ord, Read, Show)

_FunctionInvocation = Model.Name "hydra.pg.cypher.openCypher.FunctionInvocation"

_FunctionInvocation_name = Model.Name "name"

_FunctionInvocation_distinct = Model.Name "distinct"

_FunctionInvocation_arguments = Model.Name "arguments"

-- | A variable bound over a list expression, as in x IN list
data IdInColl =
  IdInColl {
    idInCollVariable :: Variable,
    idInCollExpression :: Expression}
  deriving (Eq, Ord, Read, Show)

_IdInColl = Model.Name "hydra.pg.cypher.openCypher.IdInColl"

_IdInColl_variable = Model.Name "variable"

_IdInColl_expression = Model.Name "expression"

-- | A procedure call with no argument list, taking its arguments from bound variables
newtype ImplicitProcedureInvocation =
  ImplicitProcedureInvocation {
    unImplicitProcedureInvocation :: QualifiedName}
  deriving (Eq, Ord, Read, Show)

_ImplicitProcedureInvocation = Model.Name "hydra.pg.cypher.openCypher.ImplicitProcedureInvocation"

-- | An in-query CALL to a procedure
data InQueryCall =
  InQueryCall {
    inQueryCallCall :: ExplicitProcedureInvocation,
    inQueryCallYieldItems :: (Maybe YieldItems)}
  deriving (Eq, Ord, Read, Show)

_InQueryCall = Model.Name "hydra.pg.cypher.openCypher.InQueryCall"

_InQueryCall_call = Model.Name "call"

_InQueryCall_yieldItems = Model.Name "yieldItems"

-- | A key-value pair in a map literal
data KeyValuePair =
  KeyValuePair {
    keyValuePairKey :: PropertyKeyName,
    keyValuePairValue :: Expression}
  deriving (Eq, Ord, Read, Show)

_KeyValuePair = Model.Name "hydra.pg.cypher.openCypher.KeyValuePair"

_KeyValuePair_key = Model.Name "key"

_KeyValuePair_value = Model.Name "value"

-- | A LIMIT clause limiting the number of results
newtype Limit =
  Limit {
    unLimit :: Expression}
  deriving (Eq, Ord, Read, Show)

_Limit = Model.Name "hydra.pg.cypher.openCypher.Limit"

-- | A list comprehension: a filter expression with an optional projection
data ListComprehension =
  ListComprehension {
    listComprehensionLeft :: FilterExpression,
    listComprehensionRight :: (Maybe Expression)}
  deriving (Eq, Ord, Read, Show)

_ListComprehension = Model.Name "hydra.pg.cypher.openCypher.ListComprehension"

_ListComprehension_left = Model.Name "left"

_ListComprehension_right = Model.Name "right"

-- | A list literal
newtype ListLiteral =
  ListLiteral {
    unListLiteral :: [Expression]}
  deriving (Eq, Ord, Read, Show)

_ListLiteral = Model.Name "hydra.pg.cypher.openCypher.ListLiteral"

-- | A list operator applied to a non-arithmetic operator expression: indexing or slicing
data ListOperatorExpression =
  ListOperatorExpressionSingle Expression |
  ListOperatorExpressionRange RangeExpression
  deriving (Eq, Ord, Read, Show)

_ListOperatorExpression = Model.Name "hydra.pg.cypher.openCypher.ListOperatorExpression"

_ListOperatorExpression_single = Model.Name "single"

_ListOperatorExpression_range = Model.Name "range"

-- | A list operator or property lookup applied to an atom
data ListOperatorExpressionOrPropertyLookup =
  ListOperatorExpressionOrPropertyLookupList ListOperatorExpression |
  ListOperatorExpressionOrPropertyLookupProperty PropertyLookup
  deriving (Eq, Ord, Read, Show)

_ListOperatorExpressionOrPropertyLookup = Model.Name "hydra.pg.cypher.openCypher.ListOperatorExpressionOrPropertyLookup"

_ListOperatorExpressionOrPropertyLookup_list = Model.Name "list"

_ListOperatorExpressionOrPropertyLookup_property = Model.Name "property"

-- | An IN predicate testing list membership
newtype ListPredicateExpression =
  ListPredicateExpression {
    unListPredicateExpression :: AddOrSubtractExpression}
  deriving (Eq, Ord, Read, Show)

_ListPredicateExpression = Model.Name "hydra.pg.cypher.openCypher.ListPredicateExpression"

-- | A literal value: a number, string, boolean, null, list, or map
data Literal =
  LiteralBoolean Bool |
  LiteralNull |
  LiteralNumber NumberLiteral |
  LiteralString StringLiteral |
  LiteralList ListLiteral |
  LiteralMap MapLiteral
  deriving (Eq, Ord, Read, Show)

_Literal = Model.Name "hydra.pg.cypher.openCypher.Literal"

_Literal_boolean = Model.Name "boolean"

_Literal_null = Model.Name "null"

_Literal_number = Model.Name "number"

_Literal_string = Model.Name "string"

_Literal_list = Model.Name "list"

_Literal_map = Model.Name "map"

-- | A map literal
newtype MapLiteral =
  MapLiteral {
    unMapLiteral :: [KeyValuePair]}
  deriving (Eq, Ord, Read, Show)

_MapLiteral = Model.Name "hydra.pg.cypher.openCypher.MapLiteral"

-- | A MATCH clause, optionally OPTIONAL, over a pattern with an optional WHERE clause
data Match =
  Match {
    matchOptional :: Bool,
    matchPattern :: Pattern,
    matchWhere :: (Maybe Where)}
  deriving (Eq, Ord, Read, Show)

_Match = Model.Name "hydra.pg.cypher.openCypher.Match"

_Match_optional = Model.Name "optional"

_Match_pattern = Model.Name "pattern"

_Match_where = Model.Name "where"

-- | Either a MATCH or a CREATE, used within a MERGE action
data MatchOrCreate =
  MatchOrCreateMatch |
  MatchOrCreateCreate
  deriving (Eq, Ord, Read, Show)

_MatchOrCreate = Model.Name "hydra.pg.cypher.openCypher.MatchOrCreate"

_MatchOrCreate_match = Model.Name "match"

_MatchOrCreate_create = Model.Name "create"

-- | A MERGE clause matching or creating a pattern, with optional merge actions
data Merge =
  Merge {
    mergePatternPart :: PatternPart,
    mergeActions :: [MergeAction]}
  deriving (Eq, Ord, Read, Show)

_Merge = Model.Name "hydra.pg.cypher.openCypher.Merge"

_Merge_patternPart = Model.Name "patternPart"

_Merge_actions = Model.Name "actions"

-- | An ON MATCH or ON CREATE action attached to a MERGE clause
data MergeAction =
  MergeAction {
    mergeActionAction :: MatchOrCreate,
    mergeActionSet :: Set}
  deriving (Eq, Ord, Read, Show)

_MergeAction = Model.Name "hydra.pg.cypher.openCypher.MergeAction"

_MergeAction_action = Model.Name "action"

_MergeAction_set = Model.Name "set"

-- | A multi-part query: one or more WITH-delimited parts followed by a single-part query
data MultiPartQuery =
  MultiPartQuery {
    multiPartQueryWith :: [WithClause],
    multiPartQueryBody :: SinglePartQuery}
  deriving (Eq, Ord, Read, Show)

_MultiPartQuery = Model.Name "hydra.pg.cypher.openCypher.MultiPartQuery"

_MultiPartQuery_with = Model.Name "with"

_MultiPartQuery_body = Model.Name "body"

-- | A multiplicative expression: a power expression with zero or more multiply, divide, or modulo terms
data MultiplyDivideModuloExpression =
  MultiplyDivideModuloExpression {
    multiplyDivideModuloExpressionLeft :: PowerOfExpression,
    multiplyDivideModuloExpressionRight :: [MultiplyDivideModuloRightHandSide]}
  deriving (Eq, Ord, Read, Show)

_MultiplyDivideModuloExpression = Model.Name "hydra.pg.cypher.openCypher.MultiplyDivideModuloExpression"

_MultiplyDivideModuloExpression_left = Model.Name "left"

_MultiplyDivideModuloExpression_right = Model.Name "right"

-- | A multiplicative operator: *, /, or %
data MultiplyDivideModuloOperator =
  MultiplyDivideModuloOperatorMultiply |
  MultiplyDivideModuloOperatorDivide |
  MultiplyDivideModuloOperatorModulo
  deriving (Eq, Ord, Read, Show)

_MultiplyDivideModuloOperator = Model.Name "hydra.pg.cypher.openCypher.MultiplyDivideModuloOperator"

_MultiplyDivideModuloOperator_multiply = Model.Name "multiply"

_MultiplyDivideModuloOperator_divide = Model.Name "divide"

_MultiplyDivideModuloOperator_modulo = Model.Name "modulo"

-- | A multiplicative operator applied to a right-hand power expression
data MultiplyDivideModuloRightHandSide =
  MultiplyDivideModuloRightHandSide {
    multiplyDivideModuloRightHandSideOperator :: MultiplyDivideModuloOperator,
    multiplyDivideModuloRightHandSideExpression :: PowerOfExpression}
  deriving (Eq, Ord, Read, Show)

_MultiplyDivideModuloRightHandSide = Model.Name "hydra.pg.cypher.openCypher.MultiplyDivideModuloRightHandSide"

_MultiplyDivideModuloRightHandSide_operator = Model.Name "operator"

_MultiplyDivideModuloRightHandSide_expression = Model.Name "expression"

-- | A single node label
newtype NodeLabel =
  NodeLabel {
    unNodeLabel :: String}
  deriving (Eq, Ord, Read, Show)

_NodeLabel = Model.Name "hydra.pg.cypher.openCypher.NodeLabel"

-- | One or more node labels attached to a node pattern
newtype NodeLabels =
  NodeLabels {
    unNodeLabels :: [NodeLabel]}
  deriving (Eq, Ord, Read, Show)

_NodeLabels = Model.Name "hydra.pg.cypher.openCypher.NodeLabels"

-- | A node pattern: an optional variable, node labels, and properties
data NodePattern =
  NodePattern {
    nodePatternVariable :: (Maybe Variable),
    nodePatternLabels :: (Maybe NodeLabels),
    nodePatternProperties :: (Maybe Properties)}
  deriving (Eq, Ord, Read, Show)

_NodePattern = Model.Name "hydra.pg.cypher.openCypher.NodePattern"

_NodePattern_variable = Model.Name "variable"

_NodePattern_labels = Model.Name "labels"

_NodePattern_properties = Model.Name "properties"

-- | A node pattern followed by a chain of pattern-element continuations
data NodePatternChain =
  NodePatternChain {
    nodePatternChainNodePattern :: NodePattern,
    nodePatternChainChain :: [PatternElementChain]}
  deriving (Eq, Ord, Read, Show)

_NodePatternChain = Model.Name "hydra.pg.cypher.openCypher.NodePatternChain"

_NodePatternChain_nodePattern = Model.Name "nodePattern"

_NodePatternChain_chain = Model.Name "chain"

-- | An atom followed by zero or more list operators, property lookups, or node labels
data NonArithmeticOperatorExpression =
  NonArithmeticOperatorExpression {
    nonArithmeticOperatorExpressionAtom :: Atom,
    nonArithmeticOperatorExpressionListsAndLookups :: [ListOperatorExpressionOrPropertyLookup],
    nonArithmeticOperatorExpressionLabels :: (Maybe NodeLabels)}
  deriving (Eq, Ord, Read, Show)

_NonArithmeticOperatorExpression = Model.Name "hydra.pg.cypher.openCypher.NonArithmeticOperatorExpression"

_NonArithmeticOperatorExpression_atom = Model.Name "atom"

_NonArithmeticOperatorExpression_listsAndLookups = Model.Name "listsAndLookups"

_NonArithmeticOperatorExpression_labels = Model.Name "labels"

-- | A possibly-negated comparison expression
data NotExpression =
  NotExpression {
    notExpressionNot :: Bool,
    notExpressionExpression :: ComparisonExpression}
  deriving (Eq, Ord, Read, Show)

_NotExpression = Model.Name "hydra.pg.cypher.openCypher.NotExpression"

_NotExpression_not = Model.Name "not"

_NotExpression_expression = Model.Name "expression"

-- | An IS NULL or IS NOT NULL predicate
newtype NullPredicateExpression =
  NullPredicateExpression {
    unNullPredicateExpression :: Bool}
  deriving (Eq, Ord, Read, Show)

_NullPredicateExpression = Model.Name "hydra.pg.cypher.openCypher.NullPredicateExpression"

-- | A numeric literal: a double or an integer
data NumberLiteral =
  NumberLiteralDouble Double |
  NumberLiteralInteger Integer
  deriving (Eq, Ord, Read, Show)

_NumberLiteral = Model.Name "hydra.pg.cypher.openCypher.NumberLiteral"

_NumberLiteral_double = Model.Name "double"

_NumberLiteral_integer = Model.Name "integer"

-- | A disjunction of XOR expressions
newtype OrExpression =
  OrExpression {
    unOrExpression :: [XorExpression]}
  deriving (Eq, Ord, Read, Show)

_OrExpression = Model.Name "hydra.pg.cypher.openCypher.OrExpression"

-- | An ORDER BY clause
newtype Order =
  Order {
    unOrder :: [SortItem]}
  deriving (Eq, Ord, Read, Show)

_Order = Model.Name "hydra.pg.cypher.openCypher.Order"

-- | A named or positional query parameter
data Parameter =
  ParameterSymbolic String |
  ParameterInteger Integer
  deriving (Eq, Ord, Read, Show)

_Parameter = Model.Name "hydra.pg.cypher.openCypher.Parameter"

_Parameter_symbolic = Model.Name "symbolic"

_Parameter_integer = Model.Name "integer"

-- | A parenthesized expression
newtype ParenthesizedExpression =
  ParenthesizedExpression {
    unParenthesizedExpression :: Expression}
  deriving (Eq, Ord, Read, Show)

_ParenthesizedExpression = Model.Name "hydra.pg.cypher.openCypher.ParenthesizedExpression"

-- | A comparison operator applied to a right-hand add/subtract expression
data PartialComparisonExpression =
  PartialComparisonExpression {
    partialComparisonExpressionOperator :: ComparisonOperator,
    partialComparisonExpressionRight :: StringListNullPredicateExpression}
  deriving (Eq, Ord, Read, Show)

_PartialComparisonExpression = Model.Name "hydra.pg.cypher.openCypher.PartialComparisonExpression"

_PartialComparisonExpression_operator = Model.Name "operator"

_PartialComparisonExpression_right = Model.Name "right"

-- | A graph pattern: one or more pattern parts
newtype Pattern =
  Pattern {
    unPattern :: [PatternPart]}
  deriving (Eq, Ord, Read, Show)

_Pattern = Model.Name "hydra.pg.cypher.openCypher.Pattern"

-- | A pattern comprehension: a pattern with optional filter and projection expressions
data PatternComprehension =
  PatternComprehension {
    patternComprehensionVariable :: (Maybe Variable),
    patternComprehensionPattern :: RelationshipsPattern,
    patternComprehensionWhere :: (Maybe Where),
    patternComprehensionRight :: Expression}
  deriving (Eq, Ord, Read, Show)

_PatternComprehension = Model.Name "hydra.pg.cypher.openCypher.PatternComprehension"

_PatternComprehension_variable = Model.Name "variable"

_PatternComprehension_pattern = Model.Name "pattern"

_PatternComprehension_where = Model.Name "where"

_PatternComprehension_right = Model.Name "right"

-- | A pattern element: a node pattern chain or a parenthesized pattern element
data PatternElement =
  PatternElementChained NodePatternChain |
  PatternElementParenthesized PatternElement
  deriving (Eq, Ord, Read, Show)

_PatternElement = Model.Name "hydra.pg.cypher.openCypher.PatternElement"

_PatternElement_chained = Model.Name "chained"

_PatternElement_parenthesized = Model.Name "parenthesized"

-- | A relationship pattern followed by the node pattern it connects to
data PatternElementChain =
  PatternElementChain {
    patternElementChainRelationship :: RelationshipPattern,
    patternElementChainNode :: NodePattern}
  deriving (Eq, Ord, Read, Show)

_PatternElementChain = Model.Name "hydra.pg.cypher.openCypher.PatternElementChain"

_PatternElementChain_relationship = Model.Name "relationship"

_PatternElementChain_node = Model.Name "node"

-- | One part of a graph pattern, optionally bound to a variable
data PatternPart =
  PatternPart {
    patternPartVariable :: (Maybe Variable),
    patternPartPattern :: AnonymousPatternPart}
  deriving (Eq, Ord, Read, Show)

_PatternPart = Model.Name "hydra.pg.cypher.openCypher.PatternPart"

_PatternPart_variable = Model.Name "variable"

_PatternPart_pattern = Model.Name "pattern"

-- | A pattern used as a boolean existence predicate
newtype PatternPredicate =
  PatternPredicate {
    unPatternPredicate :: RelationshipsPattern}
  deriving (Eq, Ord, Read, Show)

_PatternPredicate = Model.Name "hydra.pg.cypher.openCypher.PatternPredicate"

-- | A pattern together with an optional WHERE clause, used in an existential subquery
data PatternWhere =
  PatternWhere {
    patternWherePattern :: Pattern,
    patternWhereWhere :: (Maybe Where)}
  deriving (Eq, Ord, Read, Show)

_PatternWhere = Model.Name "hydra.pg.cypher.openCypher.PatternWhere"

_PatternWhere_pattern = Model.Name "pattern"

_PatternWhere_where = Model.Name "where"

-- | An exponentiation expression: a unary expression with zero or more ^ terms
newtype PowerOfExpression =
  PowerOfExpression {
    unPowerOfExpression :: [UnaryAddOrSubtractExpression]}
  deriving (Eq, Ord, Read, Show)

_PowerOfExpression = Model.Name "hydra.pg.cypher.openCypher.PowerOfExpression"

-- | A procedure invocation: explicit (with arguments) or implicit
data ProcedureInvocation =
  ProcedureInvocationExplicit ExplicitProcedureInvocation |
  ProcedureInvocationImplicit ImplicitProcedureInvocation
  deriving (Eq, Ord, Read, Show)

_ProcedureInvocation = Model.Name "hydra.pg.cypher.openCypher.ProcedureInvocation"

_ProcedureInvocation_explicit = Model.Name "explicit"

_ProcedureInvocation_implicit = Model.Name "implicit"

-- | The name of a single field yielded by a procedure
newtype ProcedureResultField =
  ProcedureResultField {
    unProcedureResultField :: String}
  deriving (Eq, Ord, Read, Show)

_ProcedureResultField = Model.Name "hydra.pg.cypher.openCypher.ProcedureResultField"

-- | The body of a WITH or RETURN clause: distinctness, projection items, and ordering/paging
data ProjectionBody =
  ProjectionBody {
    projectionBodyDistinct :: Bool,
    projectionBodyProjectionItems :: ProjectionItems,
    projectionBodyOrder :: (Maybe Order),
    projectionBodySkip :: (Maybe Skip),
    projectionBodyLimit :: (Maybe Limit)}
  deriving (Eq, Ord, Read, Show)

_ProjectionBody = Model.Name "hydra.pg.cypher.openCypher.ProjectionBody"

_ProjectionBody_distinct = Model.Name "distinct"

_ProjectionBody_projectionItems = Model.Name "projectionItems"

_ProjectionBody_order = Model.Name "order"

_ProjectionBody_skip = Model.Name "skip"

_ProjectionBody_limit = Model.Name "limit"

-- | One item of a projection: an expression, optionally aliased
data ProjectionItem =
  ProjectionItem {
    projectionItemExpression :: Expression,
    projectionItemVariable :: (Maybe Variable)}
  deriving (Eq, Ord, Read, Show)

_ProjectionItem = Model.Name "hydra.pg.cypher.openCypher.ProjectionItem"

_ProjectionItem_expression = Model.Name "expression"

_ProjectionItem_variable = Model.Name "variable"

-- | The list of items in a projection, or a star for all variables
data ProjectionItems =
  ProjectionItems {
    projectionItemsStar :: Bool,
    projectionItemsExplicit :: [ProjectionItem]}
  deriving (Eq, Ord, Read, Show)

_ProjectionItems = Model.Name "hydra.pg.cypher.openCypher.ProjectionItems"

_ProjectionItems_star = Model.Name "star"

_ProjectionItems_explicit = Model.Name "explicit"

-- | A property map or parameter attached to a node or relationship pattern
data Properties =
  PropertiesMap MapLiteral |
  PropertiesParameter Parameter
  deriving (Eq, Ord, Read, Show)

_Properties = Model.Name "hydra.pg.cypher.openCypher.Properties"

_Properties_map = Model.Name "map"

_Properties_parameter = Model.Name "parameter"

-- | A property assignment of the form property = expression
data PropertyEquals =
  PropertyEquals {
    propertyEqualsLhs :: PropertyExpression,
    propertyEqualsRhs :: Expression}
  deriving (Eq, Ord, Read, Show)

_PropertyEquals = Model.Name "hydra.pg.cypher.openCypher.PropertyEquals"

_PropertyEquals_lhs = Model.Name "lhs"

_PropertyEquals_rhs = Model.Name "rhs"

-- | An atom followed by one or more property lookups
data PropertyExpression =
  PropertyExpression {
    propertyExpressionAtom :: Atom,
    propertyExpressionLookups :: [PropertyLookup]}
  deriving (Eq, Ord, Read, Show)

_PropertyExpression = Model.Name "hydra.pg.cypher.openCypher.PropertyExpression"

_PropertyExpression_atom = Model.Name "atom"

_PropertyExpression_lookups = Model.Name "lookups"

-- | The name of a property key
newtype PropertyKeyName =
  PropertyKeyName {
    unPropertyKeyName :: String}
  deriving (Eq, Ord, Read, Show)

_PropertyKeyName = Model.Name "hydra.pg.cypher.openCypher.PropertyKeyName"

-- | A single property access, as in .property
newtype PropertyLookup =
  PropertyLookup {
    unPropertyLookup :: PropertyKeyName}
  deriving (Eq, Ord, Read, Show)

_PropertyLookup = Model.Name "hydra.pg.cypher.openCypher.PropertyLookup"

-- | A namespace-qualified function or procedure name
data QualifiedName =
  QualifiedName {
    qualifiedNameNamespace :: String,
    qualifiedNameLocal :: String}
  deriving (Eq, Ord, Read, Show)

_QualifiedName = Model.Name "hydra.pg.cypher.openCypher.QualifiedName"

_QualifiedName_namespace = Model.Name "namespace"

_QualifiedName_local = Model.Name "local"

-- | A quantifier over a list predicate: all, any, none, or single
data Quantifier =
  Quantifier {
    quantifierOperator :: QuantifierOperator,
    quantifierExpression :: FilterExpression}
  deriving (Eq, Ord, Read, Show)

_Quantifier = Model.Name "hydra.pg.cypher.openCypher.Quantifier"

_Quantifier_operator = Model.Name "operator"

_Quantifier_expression = Model.Name "expression"

-- | The keyword of a quantifier: ALL, ANY, NONE, or SINGLE
data QuantifierOperator =
  QuantifierOperatorAll |
  QuantifierOperatorAny |
  QuantifierOperatorNone |
  QuantifierOperatorSingle
  deriving (Eq, Ord, Read, Show)

_QuantifierOperator = Model.Name "hydra.pg.cypher.openCypher.QuantifierOperator"

_QuantifierOperator_all = Model.Name "all"

_QuantifierOperator_any = Model.Name "any"

_QuantifierOperator_none = Model.Name "none"

_QuantifierOperator_single = Model.Name "single"

-- | An openCypher query: a regular query or a standalone procedure call
data Query =
  QueryRegular RegularQuery |
  QueryStandalone StandaloneCall
  deriving (Eq, Ord, Read, Show)

_Query = Model.Name "hydra.pg.cypher.openCypher.Query"

_Query_regular = Model.Name "regular"

_Query_standalone = Model.Name "standalone"

-- | The bracketed range of a list-slice operator
data RangeExpression =
  RangeExpression {
    rangeExpressionStart :: (Maybe Expression),
    rangeExpressionEnd :: (Maybe Expression)}
  deriving (Eq, Ord, Read, Show)

_RangeExpression = Model.Name "hydra.pg.cypher.openCypher.RangeExpression"

_RangeExpression_start = Model.Name "start"

_RangeExpression_end = Model.Name "end"

-- | A variable-length relationship range, as in *1..3
data RangeLiteral =
  RangeLiteral {
    rangeLiteralStart :: (Maybe Integer),
    rangeLiteralEnd :: (Maybe Integer)}
  deriving (Eq, Ord, Read, Show)

_RangeLiteral = Model.Name "hydra.pg.cypher.openCypher.RangeLiteral"

_RangeLiteral_start = Model.Name "start"

_RangeLiteral_end = Model.Name "end"

-- | A reading clause: MATCH, UNWIND, or an in-query CALL
data ReadingClause =
  ReadingClauseMatch Match |
  ReadingClauseUnwind Unwind |
  ReadingClauseInQueryCall InQueryCall
  deriving (Eq, Ord, Read, Show)

_ReadingClause = Model.Name "hydra.pg.cypher.openCypher.ReadingClause"

_ReadingClause_match = Model.Name "match"

_ReadingClause_unwind = Model.Name "unwind"

_ReadingClause_inQueryCall = Model.Name "inQueryCall"

-- | A regular openCypher query: a single query, optionally unioned with further queries
data RegularQuery =
  RegularQuery {
    regularQueryHead :: SingleQuery,
    regularQueryRest :: [Union]}
  deriving (Eq, Ord, Read, Show)

_RegularQuery = Model.Name "hydra.pg.cypher.openCypher.RegularQuery"

_RegularQuery_head = Model.Name "head"

_RegularQuery_rest = Model.Name "rest"

-- | The name of a relationship type
newtype RelTypeName =
  RelTypeName {
    unRelTypeName :: String}
  deriving (Eq, Ord, Read, Show)

_RelTypeName = Model.Name "hydra.pg.cypher.openCypher.RelTypeName"

-- | The bracketed detail of a relationship pattern: variable, types, range, and properties
data RelationshipDetail =
  RelationshipDetail {
    relationshipDetailVariable :: (Maybe Variable),
    relationshipDetailTypes :: (Maybe RelationshipTypes),
    relationshipDetailRange :: (Maybe RangeLiteral),
    relationshipDetailProperties :: (Maybe Properties)}
  deriving (Eq, Ord, Read, Show)

_RelationshipDetail = Model.Name "hydra.pg.cypher.openCypher.RelationshipDetail"

_RelationshipDetail_variable = Model.Name "variable"

_RelationshipDetail_types = Model.Name "types"

_RelationshipDetail_range = Model.Name "range"

_RelationshipDetail_properties = Model.Name "properties"

-- | A relationship pattern: direction markers around an optional relationship detail
data RelationshipPattern =
  RelationshipPattern {
    relationshipPatternLeftArrow :: Bool,
    relationshipPatternDetail :: (Maybe RelationshipDetail),
    relationshipPatternRightArrow :: Bool}
  deriving (Eq, Ord, Read, Show)

_RelationshipPattern = Model.Name "hydra.pg.cypher.openCypher.RelationshipPattern"

_RelationshipPattern_leftArrow = Model.Name "leftArrow"

_RelationshipPattern_detail = Model.Name "detail"

_RelationshipPattern_rightArrow = Model.Name "rightArrow"

-- | The relationship type disjunction of a relationship pattern
newtype RelationshipTypes =
  RelationshipTypes {
    unRelationshipTypes :: [RelTypeName]}
  deriving (Eq, Ord, Read, Show)

_RelationshipTypes = Model.Name "hydra.pg.cypher.openCypher.RelationshipTypes"

-- | A relationship pattern chain anchored at a node pattern
data RelationshipsPattern =
  RelationshipsPattern {
    relationshipsPatternNodePattern :: NodePattern,
    relationshipsPatternChain :: [PatternElementChain]}
  deriving (Eq, Ord, Read, Show)

_RelationshipsPattern = Model.Name "hydra.pg.cypher.openCypher.RelationshipsPattern"

_RelationshipsPattern_nodePattern = Model.Name "nodePattern"

_RelationshipsPattern_chain = Model.Name "chain"

-- | A REMOVE clause removing properties or labels
newtype Remove =
  Remove {
    unRemove :: [RemoveItem]}
  deriving (Eq, Ord, Read, Show)

_Remove = Model.Name "hydra.pg.cypher.openCypher.Remove"

-- | One item of a REMOVE clause
data RemoveItem =
  RemoveItemVariableLabels VariableAndNodeLabels |
  RemoveItemProperty PropertyExpression
  deriving (Eq, Ord, Read, Show)

_RemoveItem = Model.Name "hydra.pg.cypher.openCypher.RemoveItem"

_RemoveItem_variableLabels = Model.Name "variableLabels"

_RemoveItem_property = Model.Name "property"

-- | The RETURN clause: a projection body producing the query's result
newtype Return =
  Return {
    unReturn :: ProjectionBody}
  deriving (Eq, Ord, Read, Show)

_Return = Model.Name "hydra.pg.cypher.openCypher.Return"

-- | A SET clause updating properties or labels
newtype Set =
  Set {
    unSet :: [SetItem]}
  deriving (Eq, Ord, Read, Show)

_Set = Model.Name "hydra.pg.cypher.openCypher.Set"

-- | One item of a SET clause
data SetItem =
  SetItemProperty PropertyEquals |
  SetItemVariableEqual VariableEquals |
  SetItemVariablePlusEqual VariablePlusEquals |
  SetItemVariableLabels VariableAndNodeLabels
  deriving (Eq, Ord, Read, Show)

_SetItem = Model.Name "hydra.pg.cypher.openCypher.SetItem"

_SetItem_property = Model.Name "property"

_SetItem_variableEqual = Model.Name "variableEqual"

_SetItem_variablePlusEqual = Model.Name "variablePlusEqual"

_SetItem_variableLabels = Model.Name "variableLabels"

-- | A single-part query: reading and updating clauses followed by an optional RETURN clause
data SinglePartQuery =
  SinglePartQuery {
    singlePartQueryReading :: [ReadingClause],
    singlePartQueryUpdating :: [UpdatingClause],
    singlePartQueryReturn :: (Maybe Return)}
  deriving (Eq, Ord, Read, Show)

_SinglePartQuery = Model.Name "hydra.pg.cypher.openCypher.SinglePartQuery"

_SinglePartQuery_reading = Model.Name "reading"

_SinglePartQuery_updating = Model.Name "updating"

_SinglePartQuery_return = Model.Name "return"

-- | A single openCypher query: a single-part query or a multi-part query
data SingleQuery =
  SingleQuerySinglePart SinglePartQuery |
  SingleQueryMultiPart MultiPartQuery
  deriving (Eq, Ord, Read, Show)

_SingleQuery = Model.Name "hydra.pg.cypher.openCypher.SingleQuery"

_SingleQuery_singlePart = Model.Name "singlePart"

_SingleQuery_multiPart = Model.Name "multiPart"

-- | A SKIP clause limiting the starting offset of results
newtype Skip =
  Skip {
    unSkip :: Expression}
  deriving (Eq, Ord, Read, Show)

_Skip = Model.Name "hydra.pg.cypher.openCypher.Skip"

-- | One item of an ORDER BY clause: an expression and its sort order
data SortItem =
  SortItem {
    sortItemExpression :: Expression,
    sortItemOrder :: (Maybe SortOrder)}
  deriving (Eq, Ord, Read, Show)

_SortItem = Model.Name "hydra.pg.cypher.openCypher.SortItem"

_SortItem_expression = Model.Name "expression"

_SortItem_order = Model.Name "order"

-- | The sort order of a sort item: ascending or descending
data SortOrder =
  SortOrderAscending |
  SortOrderDescending
  deriving (Eq, Ord, Read, Show)

_SortOrder = Model.Name "hydra.pg.cypher.openCypher.SortOrder"

_SortOrder_ascending = Model.Name "ascending"

_SortOrder_descending = Model.Name "descending"

-- | A standalone CALL statement invoking a procedure without a surrounding query
data StandaloneCall =
  StandaloneCall {
    standaloneCallCall :: ProcedureInvocation,
    standaloneCallYieldItems :: (Maybe StarOrYieldItems)}
  deriving (Eq, Ord, Read, Show)

_StandaloneCall = Model.Name "hydra.pg.cypher.openCypher.StandaloneCall"

_StandaloneCall_call = Model.Name "call"

_StandaloneCall_yieldItems = Model.Name "yieldItems"

-- | The result-selection clause of a standalone CALL: a star, or explicit YIELD items
data StarOrYieldItems =
  StarOrYieldItemsStar |
  StarOrYieldItemsItems YieldItems
  deriving (Eq, Ord, Read, Show)

_StarOrYieldItems = Model.Name "hydra.pg.cypher.openCypher.StarOrYieldItems"

_StarOrYieldItems_star = Model.Name "star"

_StarOrYieldItems_items = Model.Name "items"

-- | An add/subtract expression with zero or more string, list, or null predicates
data StringListNullPredicateExpression =
  StringListNullPredicateExpression {
    stringListNullPredicateExpressionLeft :: AddOrSubtractExpression,
    stringListNullPredicateExpressionRight :: [StringListNullPredicateRightHandSide]}
  deriving (Eq, Ord, Read, Show)

_StringListNullPredicateExpression = Model.Name "hydra.pg.cypher.openCypher.StringListNullPredicateExpression"

_StringListNullPredicateExpression_left = Model.Name "left"

_StringListNullPredicateExpression_right = Model.Name "right"

-- | A string, list, or null predicate applied to an expression
data StringListNullPredicateRightHandSide =
  StringListNullPredicateRightHandSideString StringPredicateExpression |
  StringListNullPredicateRightHandSideList ListPredicateExpression |
  StringListNullPredicateRightHandSideNull NullPredicateExpression
  deriving (Eq, Ord, Read, Show)

_StringListNullPredicateRightHandSide = Model.Name "hydra.pg.cypher.openCypher.StringListNullPredicateRightHandSide"

_StringListNullPredicateRightHandSide_string = Model.Name "string"

_StringListNullPredicateRightHandSide_list = Model.Name "list"

_StringListNullPredicateRightHandSide_null = Model.Name "null"

-- | A string literal
newtype StringLiteral =
  StringLiteral {
    unStringLiteral :: String}
  deriving (Eq, Ord, Read, Show)

_StringLiteral = Model.Name "hydra.pg.cypher.openCypher.StringLiteral"

-- | A string predicate: STARTS WITH, ENDS WITH, or CONTAINS
data StringPredicateExpression =
  StringPredicateExpression {
    stringPredicateExpressionOperator :: StringPredicateOperator,
    stringPredicateExpressionExpression :: AddOrSubtractExpression}
  deriving (Eq, Ord, Read, Show)

_StringPredicateExpression = Model.Name "hydra.pg.cypher.openCypher.StringPredicateExpression"

_StringPredicateExpression_operator = Model.Name "operator"

_StringPredicateExpression_expression = Model.Name "expression"

-- | A string predicate operator: STARTS WITH, ENDS WITH, or CONTAINS
data StringPredicateOperator =
  StringPredicateOperatorStartsWith |
  StringPredicateOperatorEndsWith |
  StringPredicateOperatorContains
  deriving (Eq, Ord, Read, Show)

_StringPredicateOperator = Model.Name "hydra.pg.cypher.openCypher.StringPredicateOperator"

_StringPredicateOperator_startsWith = Model.Name "startsWith"

_StringPredicateOperator_endsWith = Model.Name "endsWith"

_StringPredicateOperator_contains = Model.Name "contains"

-- | A unary plus or minus applied to a list-operator expression
data UnaryAddOrSubtractExpression =
  UnaryAddOrSubtractExpression {
    unaryAddOrSubtractExpressionOperator :: (Maybe AddOrSubtractOperator),
    unaryAddOrSubtractExpressionExpression :: NonArithmeticOperatorExpression}
  deriving (Eq, Ord, Read, Show)

_UnaryAddOrSubtractExpression = Model.Name "hydra.pg.cypher.openCypher.UnaryAddOrSubtractExpression"

_UnaryAddOrSubtractExpression_operator = Model.Name "operator"

_UnaryAddOrSubtractExpression_expression = Model.Name "expression"

-- | A UNION combining a single query with a preceding query, with optional ALL semantics
data Union =
  Union {
    unionAll :: Bool,
    unionQuery :: SingleQuery}
  deriving (Eq, Ord, Read, Show)

_Union = Model.Name "hydra.pg.cypher.openCypher.Union"

_Union_all = Model.Name "all"

_Union_query = Model.Name "query"

-- | An UNWIND clause expanding a list expression into bound rows
data Unwind =
  Unwind {
    unwindExpression :: Expression,
    unwindVariable :: Variable}
  deriving (Eq, Ord, Read, Show)

_Unwind = Model.Name "hydra.pg.cypher.openCypher.Unwind"

_Unwind_expression = Model.Name "expression"

_Unwind_variable = Model.Name "variable"

-- | An updating clause: CREATE, MERGE, SET, DELETE, or REMOVE
data UpdatingClause =
  UpdatingClauseCreate Create |
  UpdatingClauseMerge Merge |
  UpdatingClauseDelete Delete |
  UpdatingClauseSet Set |
  UpdatingClauseRemove Remove
  deriving (Eq, Ord, Read, Show)

_UpdatingClause = Model.Name "hydra.pg.cypher.openCypher.UpdatingClause"

_UpdatingClause_create = Model.Name "create"

_UpdatingClause_merge = Model.Name "merge"

_UpdatingClause_delete = Model.Name "delete"

_UpdatingClause_set = Model.Name "set"

_UpdatingClause_remove = Model.Name "remove"

-- | A variable name
newtype Variable =
  Variable {
    unVariable :: String}
  deriving (Eq, Ord, Read, Show)

_Variable = Model.Name "hydra.pg.cypher.openCypher.Variable"

-- | A variable together with node labels to set, as in SET n:Label
data VariableAndNodeLabels =
  VariableAndNodeLabels {
    variableAndNodeLabelsVariable :: Variable,
    variableAndNodeLabelsLabels :: NodeLabels}
  deriving (Eq, Ord, Read, Show)

_VariableAndNodeLabels = Model.Name "hydra.pg.cypher.openCypher.VariableAndNodeLabels"

_VariableAndNodeLabels_variable = Model.Name "variable"

_VariableAndNodeLabels_labels = Model.Name "labels"

-- | A variable assignment of the form variable = expression
data VariableEquals =
  VariableEquals {
    variableEqualsLhs :: Variable,
    variableEqualsRhs :: Expression}
  deriving (Eq, Ord, Read, Show)

_VariableEquals = Model.Name "hydra.pg.cypher.openCypher.VariableEquals"

_VariableEquals_lhs = Model.Name "lhs"

_VariableEquals_rhs = Model.Name "rhs"

-- | A variable increment assignment of the form variable += expression
data VariablePlusEquals =
  VariablePlusEquals {
    variablePlusEqualsLhs :: Variable,
    variablePlusEqualsRhs :: Expression}
  deriving (Eq, Ord, Read, Show)

_VariablePlusEquals = Model.Name "hydra.pg.cypher.openCypher.VariablePlusEquals"

_VariablePlusEquals_lhs = Model.Name "lhs"

_VariablePlusEquals_rhs = Model.Name "rhs"

-- | A WHERE clause filtering by an expression
newtype Where =
  Where {
    unWhere :: Expression}
  deriving (Eq, Ord, Read, Show)

_Where = Model.Name "hydra.pg.cypher.openCypher.Where"

-- | The WITH keyword clause: a projection body carrying values forward
data With =
  With {
    withProjection :: ProjectionBody,
    withWhere :: (Maybe Where)}
  deriving (Eq, Ord, Read, Show)

_With = Model.Name "hydra.pg.cypher.openCypher.With"

_With_projection = Model.Name "projection"

_With_where = Model.Name "where"

-- | A WITH clause carrying projected values forward, with optional WHERE filtering
data WithClause =
  WithClause {
    withClauseReading :: [ReadingClause],
    withClauseUpdating :: [UpdatingClause],
    withClauseWith :: With}
  deriving (Eq, Ord, Read, Show)

_WithClause = Model.Name "hydra.pg.cypher.openCypher.WithClause"

_WithClause_reading = Model.Name "reading"

_WithClause_updating = Model.Name "updating"

_WithClause_with = Model.Name "with"

-- | An exclusive-or of AND expressions
newtype XorExpression =
  XorExpression {
    unXorExpression :: [AndExpression]}
  deriving (Eq, Ord, Read, Show)

_XorExpression = Model.Name "hydra.pg.cypher.openCypher.XorExpression"

-- | One yielded field of a procedure call, with an optional alias
data YieldItem =
  YieldItem {
    yieldItemField :: (Maybe ProcedureResultField),
    yieldItemVariable :: Variable}
  deriving (Eq, Ord, Read, Show)

_YieldItem = Model.Name "hydra.pg.cypher.openCypher.YieldItem"

_YieldItem_field = Model.Name "field"

_YieldItem_variable = Model.Name "variable"

-- | The YIELD items of a standalone CALL, with an optional WHERE clause
data YieldItems =
  YieldItems {
    yieldItemsItems :: [YieldItem],
    yieldItemsWhere :: (Maybe Where)}
  deriving (Eq, Ord, Read, Show)

_YieldItems = Model.Name "hydra.pg.cypher.openCypher.YieldItems"

_YieldItems_items = Model.Name "items"

_YieldItems_where = Model.Name "where"