hydra-pg-0.17.2: src/main/haskell/OpenGql/Grammar.hs

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

-- | A GQL model based on the OpenGQL ANTLR grammar, version 15b256b (2024-09-05), available at: https://github.com/opengql/grammar/blob/main/GQL.g4

module OpenGql.Grammar where

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

-- | A GQL abbreviated edge pattern: one of a fixed set of alternatives
data AbbreviatedEdgePattern =
  AbbreviatedEdgePatternLeftArrow |
  AbbreviatedEdgePatternTilde |
  AbbreviatedEdgePatternRightArrow |
  AbbreviatedEdgePatternLeftArrowTilde |
  AbbreviatedEdgePatternTildeRightArrow |
  AbbreviatedEdgePatternLeftMinusRight |
  AbbreviatedEdgePatternMinusSign
  deriving (Eq, Ord, Read, Show)

_AbbreviatedEdgePattern = Core.Name "openGql.grammar.AbbreviatedEdgePattern"

_AbbreviatedEdgePattern_leftArrow = Core.Name "leftArrow"

_AbbreviatedEdgePattern_tilde = Core.Name "tilde"

_AbbreviatedEdgePattern_rightArrow = Core.Name "rightArrow"

_AbbreviatedEdgePattern_leftArrowTilde = Core.Name "leftArrowTilde"

_AbbreviatedEdgePattern_tildeRightArrow = Core.Name "tildeRightArrow"

_AbbreviatedEdgePattern_leftMinusRight = Core.Name "leftMinusRight"

_AbbreviatedEdgePattern_minusSign = Core.Name "minusSign"

-- | A GQL absolute catalog schema reference: one of several alternative forms
data AbsoluteCatalogSchemaReference =
  AbsoluteCatalogSchemaReferenceRoot |
  AbsoluteCatalogSchemaReferenceDirectoryAndSchema AbsoluteDirectoryAndSchema
  deriving (Eq, Ord, Read, Show)

_AbsoluteCatalogSchemaReference = Core.Name "openGql.grammar.AbsoluteCatalogSchemaReference"

_AbsoluteCatalogSchemaReference_root = Core.Name "root"

_AbsoluteCatalogSchemaReference_directoryAndSchema = Core.Name "directoryAndSchema"

-- | A GQL absolute directory and schema
data AbsoluteDirectoryAndSchema =
  AbsoluteDirectoryAndSchema {
    absoluteDirectoryAndSchemaDirectoryPath :: AbsoluteDirectoryPath,
    absoluteDirectoryAndSchemaSchemaName :: SchemaName}
  deriving (Eq, Ord, Read, Show)

_AbsoluteDirectoryAndSchema = Core.Name "openGql.grammar.AbsoluteDirectoryAndSchema"

_AbsoluteDirectoryAndSchema_directoryPath = Core.Name "directoryPath"

_AbsoluteDirectoryAndSchema_schemaName = Core.Name "schemaName"

-- | An optional GQL absolute directory path
type AbsoluteDirectoryPath = (Maybe SimpleDirectoryPath)

_AbsoluteDirectoryPath = Core.Name "openGql.grammar.AbsoluteDirectoryPath"

-- | A GQL absolute value expression, equivalent to a value expression
type AbsoluteValueExpression = ValueExpression

_AbsoluteValueExpression = Core.Name "openGql.grammar.AbsoluteValueExpression"

-- | A GQL addition subtraction numeric value expression
data AddSubNumericValueExpression =
  AddSubNumericValueExpression {
    addSubNumericValueExpressionLeft :: NumericValueExpression,
    addSubNumericValueExpressionOperator :: AddSubtractOperator,
    addSubNumericValueExpressionRight :: NumericValueExpression}
  deriving (Eq, Ord, Read, Show)

_AddSubNumericValueExpression = Core.Name "openGql.grammar.AddSubNumericValueExpression"

_AddSubNumericValueExpression_left = Core.Name "left"

_AddSubNumericValueExpression_operator = Core.Name "operator"

_AddSubNumericValueExpression_right = Core.Name "right"

-- | A GQL addition subtract expression
data AddSubtractExpr =
  AddSubtractExpr {
    addSubtractExprLeft :: ValueExpression,
    addSubtractExprOperator :: AddSubtractOperator,
    addSubtractExprRight :: ValueExpression}
  deriving (Eq, Ord, Read, Show)

_AddSubtractExpr = Core.Name "openGql.grammar.AddSubtractExpr"

_AddSubtractExpr_left = Core.Name "left"

_AddSubtractExpr_operator = Core.Name "operator"

_AddSubtractExpr_right = Core.Name "right"

-- | A GQL addition subtract operator: one of a fixed set of alternatives
data AddSubtractOperator =
  AddSubtractOperatorAdd |
  AddSubtractOperatorSubtract
  deriving (Eq, Ord, Read, Show)

_AddSubtractOperator = Core.Name "openGql.grammar.AddSubtractOperator"

_AddSubtractOperator_add = Core.Name "add"

_AddSubtractOperator_subtract = Core.Name "subtract"

-- | A GQL aggregate function: one of several alternative forms
data AggregateFunction =
  AggregateFunctionCountAll |
  AggregateFunctionGeneralSetFunction GeneralSetFunction |
  AggregateFunctionBinarySetFunction BinarySetFunction
  deriving (Eq, Ord, Read, Show)

_AggregateFunction = Core.Name "openGql.grammar.AggregateFunction"

_AggregateFunction_countAll = Core.Name "countAll"

_AggregateFunction_generalSetFunction = Core.Name "generalSetFunction"

_AggregateFunction_binarySetFunction = Core.Name "binarySetFunction"

-- | A GQL aggregating value expression, equivalent to a value expression
type AggregatingValueExpression = ValueExpression

_AggregatingValueExpression = Core.Name "openGql.grammar.AggregatingValueExpression"

-- | A GQL all different predicate
data AllDifferentPredicate =
  AllDifferentPredicate {
    allDifferentPredicateReferences :: [ElementVariableReference]}
  deriving (Eq, Ord, Read, Show)

_AllDifferentPredicate = Core.Name "openGql.grammar.AllDifferentPredicate"

_AllDifferentPredicate_references = Core.Name "references"

-- | A GQL all parameters or characteristics
data AllParametersOrCharacteristics =
  AllParametersOrCharacteristics {
    allParametersOrCharacteristicsAll :: Bool,
    allParametersOrCharacteristicsType :: ParametersOrCharacteristics}
  deriving (Eq, Ord, Read, Show)

_AllParametersOrCharacteristics = Core.Name "openGql.grammar.AllParametersOrCharacteristics"

_AllParametersOrCharacteristics_all = Core.Name "all"

_AllParametersOrCharacteristics_type = Core.Name "type"

-- | A GQL all path search
data AllPathSearch =
  AllPathSearch {
    allPathSearchMode :: (Maybe PathMode),
    allPathSearchOrPaths :: (Maybe PathOrPaths)}
  deriving (Eq, Ord, Read, Show)

_AllPathSearch = Core.Name "openGql.grammar.AllPathSearch"

_AllPathSearch_mode = Core.Name "mode"

_AllPathSearch_orPaths = Core.Name "orPaths"

-- | A GQL all shortest path search
data AllShortestPathSearch =
  AllShortestPathSearch {
    allShortestPathSearchMode :: (Maybe PathMode),
    allShortestPathSearchOrPaths :: (Maybe PathOrPaths)}
  deriving (Eq, Ord, Read, Show)

_AllShortestPathSearch = Core.Name "openGql.grammar.AllShortestPathSearch"

_AllShortestPathSearch_mode = Core.Name "mode"

_AllShortestPathSearch_orPaths = Core.Name "orPaths"

-- | A GQL ambient linear data modifying statement: one of several alternative forms
data AmbientLinearDataModifyingStatement =
  AmbientLinearDataModifyingStatementSimple AmbientLinearDataModifyingStatementBody |
  AmbientLinearDataModifyingStatementNested NestedDataModifyingProcedureSpecification
  deriving (Eq, Ord, Read, Show)

_AmbientLinearDataModifyingStatement = Core.Name "openGql.grammar.AmbientLinearDataModifyingStatement"

_AmbientLinearDataModifyingStatement_simple = Core.Name "simple"

_AmbientLinearDataModifyingStatement_nested = Core.Name "nested"

-- | A GQL ambient linear data modifying statement body
data AmbientLinearDataModifyingStatementBody =
  AmbientLinearDataModifyingStatementBody {
    ambientLinearDataModifyingStatementBodySimpleAccess :: SimpleLinearDataAccessingStatement,
    ambientLinearDataModifyingStatementBodyPrimitiveResult :: (Maybe PrimitiveResultStatement)}
  deriving (Eq, Ord, Read, Show)

_AmbientLinearDataModifyingStatementBody = Core.Name "openGql.grammar.AmbientLinearDataModifyingStatementBody"

_AmbientLinearDataModifyingStatementBody_simpleAccess = Core.Name "simpleAccess"

_AmbientLinearDataModifyingStatementBody_primitiveResult = Core.Name "primitiveResult"

-- | A GQL ambient linear query statement: one of several alternative forms
data AmbientLinearQueryStatement =
  AmbientLinearQueryStatementSimple AmbientLinearQueryStatementSimpleAndPrimitiveResult |
  AmbientLinearQueryStatementNested NestedQuerySpecification
  deriving (Eq, Ord, Read, Show)

_AmbientLinearQueryStatement = Core.Name "openGql.grammar.AmbientLinearQueryStatement"

_AmbientLinearQueryStatement_simple = Core.Name "simple"

_AmbientLinearQueryStatement_nested = Core.Name "nested"

-- | A GQL ambient linear query statement simple and primitive result
data AmbientLinearQueryStatementSimpleAndPrimitiveResult =
  AmbientLinearQueryStatementSimpleAndPrimitiveResult {
    ambientLinearQueryStatementSimpleAndPrimitiveResultSimple :: (Maybe SimpleLinearQueryStatement),
    ambientLinearQueryStatementSimpleAndPrimitiveResultPrimitiveResult :: PrimitiveResultStatement}
  deriving (Eq, Ord, Read, Show)

_AmbientLinearQueryStatementSimpleAndPrimitiveResult =
    Core.Name "openGql.grammar.AmbientLinearQueryStatementSimpleAndPrimitiveResult"

_AmbientLinearQueryStatementSimpleAndPrimitiveResult_simple = Core.Name "simple"

_AmbientLinearQueryStatementSimpleAndPrimitiveResult_primitiveResult = Core.Name "primitiveResult"

-- | A GQL any path search
data AnyPathSearch =
  AnyPathSearch {
    anyPathSearchNumberOfPaths :: (Maybe NumberOfPaths),
    anyPathSearchMode :: (Maybe PathMode),
    anyPathSearchOrPaths :: (Maybe PathOrPaths)}
  deriving (Eq, Ord, Read, Show)

_AnyPathSearch = Core.Name "openGql.grammar.AnyPathSearch"

_AnyPathSearch_numberOfPaths = Core.Name "numberOfPaths"

_AnyPathSearch_mode = Core.Name "mode"

_AnyPathSearch_orPaths = Core.Name "orPaths"

-- | A GQL any record type
data AnyRecordType =
  AnyRecordType {
    anyRecordTypeAny :: Bool,
    anyRecordTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_AnyRecordType = Core.Name "openGql.grammar.AnyRecordType"

_AnyRecordType_any = Core.Name "any"

_AnyRecordType_notNull = Core.Name "notNull"

-- | A GQL any shortest path search
data AnyShortestPathSearch =
  AnyShortestPathSearch {
    anyShortestPathSearchMode :: (Maybe PathMode),
    anyShortestPathSearchOrPaths :: (Maybe PathOrPaths)}
  deriving (Eq, Ord, Read, Show)

_AnyShortestPathSearch = Core.Name "openGql.grammar.AnyShortestPathSearch"

_AnyShortestPathSearch_mode = Core.Name "mode"

_AnyShortestPathSearch_orPaths = Core.Name "orPaths"

-- | A GQL approximate numeric literal: one of several alternative forms
data ApproximateNumericLiteral =
  ApproximateNumericLiteralScientificWithSuffix String |
  ApproximateNumericLiteralScientificWithoutSuffix String |
  ApproximateNumericLiteralCommonWithSuffix String |
  ApproximateNumericLiteralIntegerWithSuffix String
  deriving (Eq, Ord, Read, Show)

_ApproximateNumericLiteral = Core.Name "openGql.grammar.ApproximateNumericLiteral"

_ApproximateNumericLiteral_scientificWithSuffix = Core.Name "scientificWithSuffix"

_ApproximateNumericLiteral_scientificWithoutSuffix = Core.Name "scientificWithoutSuffix"

_ApproximateNumericLiteral_commonWithSuffix = Core.Name "commonWithSuffix"

_ApproximateNumericLiteral_integerWithSuffix = Core.Name "integerWithSuffix"

-- | A GQL approximate numeric type: one of several alternative forms
data ApproximateNumericType =
  ApproximateNumericTypeFloat16 Float16Type |
  ApproximateNumericTypeFloat32 Float32Type |
  ApproximateNumericTypeFloat64 Float64Type |
  ApproximateNumericTypeFloat128 Float128Type |
  ApproximateNumericTypeFloat256 Float256Type |
  ApproximateNumericTypeFloatWithPrecision FloatTypeWithPrecision |
  ApproximateNumericTypeReal RealType |
  ApproximateNumericTypeDoubleWithPrecision DoubleTypeWithPrecision
  deriving (Eq, Ord, Read, Show)

_ApproximateNumericType = Core.Name "openGql.grammar.ApproximateNumericType"

_ApproximateNumericType_float16 = Core.Name "float16"

_ApproximateNumericType_float32 = Core.Name "float32"

_ApproximateNumericType_float64 = Core.Name "float64"

_ApproximateNumericType_float128 = Core.Name "float128"

_ApproximateNumericType_float256 = Core.Name "float256"

_ApproximateNumericType_floatWithPrecision = Core.Name "floatWithPrecision"

_ApproximateNumericType_real = Core.Name "real"

_ApproximateNumericType_doubleWithPrecision = Core.Name "doubleWithPrecision"

-- | A GQL arc type pointing left, equivalent to a edge type filler
type ArcTypePointingLeft = EdgeTypeFiller

_ArcTypePointingLeft = Core.Name "openGql.grammar.ArcTypePointingLeft"

-- | A GQL arc type pointing right, equivalent to a edge type filler
type ArcTypePointingRight = EdgeTypeFiller

_ArcTypePointingRight = Core.Name "openGql.grammar.ArcTypePointingRight"

-- | A GQL arc type undirected, equivalent to a edge type filler
type ArcTypeUndirected = EdgeTypeFiller

_ArcTypeUndirected = Core.Name "openGql.grammar.ArcTypeUndirected"

-- | A GQL at schema clause, equivalent to a schema reference
type AtSchemaClause = SchemaReference

_AtSchemaClause = Core.Name "openGql.grammar.AtSchemaClause"

-- | A GQL big int type
data BigIntType =
  BigIntType {
    bigIntTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_BigIntType = Core.Name "openGql.grammar.BigIntType"

_BigIntType_notNull = Core.Name "notNull"

-- | A GQL big integer type
data BigIntegerType =
  BigIntegerType {
    bigIntegerTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_BigIntegerType = Core.Name "openGql.grammar.BigIntegerType"

_BigIntegerType_notNull = Core.Name "notNull"

-- | A GQL binary exact numeric type: one of several alternative forms
data BinaryExactNumericType =
  BinaryExactNumericTypeSigned SignedBinaryExactNumericType |
  BinaryExactNumericTypeUnsigned UnsignedBinaryExactNumericType
  deriving (Eq, Ord, Read, Show)

_BinaryExactNumericType = Core.Name "openGql.grammar.BinaryExactNumericType"

_BinaryExactNumericType_signed = Core.Name "signed"

_BinaryExactNumericType_unsigned = Core.Name "unsigned"

-- | A GQL binary set function
data BinarySetFunction =
  BinarySetFunction {
    binarySetFunctionFunctionType :: BinarySetFunctionType,
    binarySetFunctionDependentValue :: DependentValueExpression,
    binarySetFunctionIndependentValue :: IndependentValueExpression}
  deriving (Eq, Ord, Read, Show)

_BinarySetFunction = Core.Name "openGql.grammar.BinarySetFunction"

_BinarySetFunction_functionType = Core.Name "functionType"

_BinarySetFunction_dependentValue = Core.Name "dependentValue"

_BinarySetFunction_independentValue = Core.Name "independentValue"

-- | A GQL binary set function type: one of a fixed set of alternatives
data BinarySetFunctionType =
  BinarySetFunctionTypePercentileCont |
  BinarySetFunctionTypePercentileDisc
  deriving (Eq, Ord, Read, Show)

_BinarySetFunctionType = Core.Name "openGql.grammar.BinarySetFunctionType"

_BinarySetFunctionType_percentileCont = Core.Name "percentileCont"

_BinarySetFunctionType_percentileDisc = Core.Name "percentileDisc"

-- | A GQL binary type
data BinaryType =
  BinaryType {
    binaryTypeFixedLength :: (Maybe FixedLength),
    binaryTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_BinaryType = Core.Name "openGql.grammar.BinaryType"

_BinaryType_fixedLength = Core.Name "fixedLength"

_BinaryType_notNull = Core.Name "notNull"

-- | A GQL binding equals value
data BindingEqualsValue =
  BindingEqualsValue {
    bindingEqualsValueBinding :: BindingVariable,
    bindingEqualsValueValue :: ValueExpression}
  deriving (Eq, Ord, Read, Show)

_BindingEqualsValue = Core.Name "openGql.grammar.BindingEqualsValue"

_BindingEqualsValue_binding = Core.Name "binding"

_BindingEqualsValue_value = Core.Name "value"

-- | A GQL binding table expression: one of several alternative forms
data BindingTableExpression =
  BindingTableExpressionNested NestedBindingTableQuerySpecification |
  BindingTableExpressionObject ObjectExpressionPrimary |
  BindingTableExpressionTable BindingTableReference |
  BindingTableExpressionName ObjectNameOrBindingVariable
  deriving (Eq, Ord, Read, Show)

_BindingTableExpression = Core.Name "openGql.grammar.BindingTableExpression"

_BindingTableExpression_nested = Core.Name "nested"

_BindingTableExpression_object = Core.Name "object"

_BindingTableExpression_table = Core.Name "table"

_BindingTableExpression_name = Core.Name "name"

-- | A GQL binding table initializer
type BindingTableInitializer = ()

_BindingTableInitializer = Core.Name "openGql.grammar.BindingTableInitializer"

-- | A GQL binding table name: one of several alternative forms
data BindingTableName =
  BindingTableNameRegularIdentifier String |
  BindingTableNameDelimitedBindingTableName DelimitedBindingTableName
  deriving (Eq, Ord, Read, Show)

_BindingTableName = Core.Name "openGql.grammar.BindingTableName"

_BindingTableName_regularIdentifier = Core.Name "regularIdentifier"

_BindingTableName_delimitedBindingTableName = Core.Name "delimitedBindingTableName"

-- | A GQL binding table reference: one of several alternative forms
data BindingTableReference =
  BindingTableReferenceParentAndTableName ParentAndTableName |
  BindingTableReferenceDelimitedBindingTableName DelimitedBindingTableName |
  BindingTableReferenceParameterSpecification ReferenceParameterSpecification
  deriving (Eq, Ord, Read, Show)

_BindingTableReference = Core.Name "openGql.grammar.BindingTableReference"

_BindingTableReference_parentAndTableName = Core.Name "parentAndTableName"

_BindingTableReference_delimitedBindingTableName = Core.Name "delimitedBindingTableName"

_BindingTableReference_parameterSpecification = Core.Name "parameterSpecification"

-- | A GQL binding table reference value type
data BindingTableReferenceValueType =
  BindingTableReferenceValueType {
    bindingTableReferenceValueTypeBindingTableType :: BindingTableType,
    bindingTableReferenceValueTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_BindingTableReferenceValueType = Core.Name "openGql.grammar.BindingTableReferenceValueType"

_BindingTableReferenceValueType_bindingTableType = Core.Name "bindingTableType"

_BindingTableReferenceValueType_notNull = Core.Name "notNull"

-- | A GQL binding table type
data BindingTableType =
  BindingTableType {
    bindingTableTypeBinding :: Bool,
    bindingTableTypeFieldTypes :: FieldTypesSpecification}
  deriving (Eq, Ord, Read, Show)

_BindingTableType = Core.Name "openGql.grammar.BindingTableType"

_BindingTableType_binding = Core.Name "binding"

_BindingTableType_fieldTypes = Core.Name "fieldTypes"

-- | A GQL binding table variable definition
data BindingTableVariableDefinition =
  BindingTableVariableDefinition {
    bindingTableVariableDefinitionBinding :: Bool,
    bindingTableVariableDefinitionVariable :: BindingVariable,
    bindingTableVariableDefinitionInitializer :: OptTypedBindingTableInitializer}
  deriving (Eq, Ord, Read, Show)

_BindingTableVariableDefinition = Core.Name "openGql.grammar.BindingTableVariableDefinition"

_BindingTableVariableDefinition_binding = Core.Name "binding"

_BindingTableVariableDefinition_variable = Core.Name "variable"

_BindingTableVariableDefinition_initializer = Core.Name "initializer"

-- | A GQL binding variable
type BindingVariable = String

_BindingVariable = Core.Name "openGql.grammar.BindingVariable"

-- | A GQL binding variable definition: one of several alternative forms
data BindingVariableDefinition =
  BindingVariableDefinitionGraph GraphVariableDefinition |
  BindingVariableDefinitionTable BindingTableVariableDefinition |
  BindingVariableDefinitionValue ValueVariableDefinition
  deriving (Eq, Ord, Read, Show)

_BindingVariableDefinition = Core.Name "openGql.grammar.BindingVariableDefinition"

_BindingVariableDefinition_graph = Core.Name "graph"

_BindingVariableDefinition_table = Core.Name "table"

_BindingVariableDefinition_value = Core.Name "value"

-- | A list of GQL binding variable definition block elements
type BindingVariableDefinitionBlock = [BindingVariableDefinition]

_BindingVariableDefinitionBlock = Core.Name "openGql.grammar.BindingVariableDefinitionBlock"

-- | A GQL binding variable reference, equivalent to a binding variable
type BindingVariableReference = BindingVariable

_BindingVariableReference = Core.Name "openGql.grammar.BindingVariableReference"

-- | A list of GQL binding variable reference list elements
type BindingVariableReferenceList = [BindingVariableReference]

_BindingVariableReferenceList = Core.Name "openGql.grammar.BindingVariableReferenceList"

-- | A GQL boolean literal: one of a fixed set of alternatives
data BooleanLiteral =
  BooleanLiteralTrue |
  BooleanLiteralFalse |
  BooleanLiteralUnknown
  deriving (Eq, Ord, Read, Show)

_BooleanLiteral = Core.Name "openGql.grammar.BooleanLiteral"

_BooleanLiteral_true = Core.Name "true"

_BooleanLiteral_false = Core.Name "false"

_BooleanLiteral_unknown = Core.Name "unknown"

-- | A GQL boolean type
data BooleanType =
  BooleanType {
    booleanTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_BooleanType = Core.Name "openGql.grammar.BooleanType"

_BooleanType_notNull = Core.Name "notNull"

-- | A GQL boolean value expression, equivalent to a value expression
type BooleanValueExpression = ValueExpression

_BooleanValueExpression = Core.Name "openGql.grammar.BooleanValueExpression"

-- | A GQL byte length expression, equivalent to a byte string value expression
type ByteLengthExpression = ByteStringValueExpression

_ByteLengthExpression = Core.Name "openGql.grammar.ByteLengthExpression"

-- | A GQL byte string literal
type ByteStringLiteral = String

_ByteStringLiteral = Core.Name "openGql.grammar.ByteStringLiteral"

-- | A GQL byte string type: one of several alternative forms
data ByteStringType =
  ByteStringTypeBytesType BytesType |
  ByteStringTypeBinaryType BinaryType |
  ByteStringTypeVarbinaryType VarbinaryType
  deriving (Eq, Ord, Read, Show)

_ByteStringType = Core.Name "openGql.grammar.ByteStringType"

_ByteStringType_bytesType = Core.Name "bytesType"

_ByteStringType_binaryType = Core.Name "binaryType"

_ByteStringType_varbinaryType = Core.Name "varbinaryType"

-- | A GQL byte string value expression, equivalent to a value expression
type ByteStringValueExpression = ValueExpression

_ByteStringValueExpression = Core.Name "openGql.grammar.ByteStringValueExpression"

-- | A GQL bytes type
data BytesType =
  BytesType {
    bytesTypeMinLength :: (Maybe MinLength),
    bytesTypeMaxLength :: (Maybe MaxLength),
    bytesTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_BytesType = Core.Name "openGql.grammar.BytesType"

_BytesType_minLength = Core.Name "minLength"

_BytesType_maxLength = Core.Name "maxLength"

_BytesType_notNull = Core.Name "notNull"

-- | A GQL call catalog modifying procedure statement, equivalent to a call procedure statement
type CallCatalogModifyingProcedureStatement = CallProcedureStatement

_CallCatalogModifyingProcedureStatement = Core.Name "openGql.grammar.CallCatalogModifyingProcedureStatement"

-- | A GQL call data modifying procedure statement, equivalent to a call procedure statement
type CallDataModifyingProcedureStatement = CallProcedureStatement

_CallDataModifyingProcedureStatement = Core.Name "openGql.grammar.CallDataModifyingProcedureStatement"

-- | A GQL call procedure statement
data CallProcedureStatement =
  CallProcedureStatement {
    callProcedureStatementOptional :: Bool,
    callProcedureStatementCall :: ProcedureCall}
  deriving (Eq, Ord, Read, Show)

_CallProcedureStatement = Core.Name "openGql.grammar.CallProcedureStatement"

_CallProcedureStatement_optional = Core.Name "optional"

_CallProcedureStatement_call = Core.Name "call"

-- | A GQL call query statement, equivalent to a call procedure statement
type CallQueryStatement = CallProcedureStatement

_CallQueryStatement = Core.Name "openGql.grammar.CallQueryStatement"

-- | A GQL cardinality argument expression, equivalent to a value expression
type CardinalityArgumentExpression = ValueExpression

_CardinalityArgumentExpression = Core.Name "openGql.grammar.CardinalityArgumentExpression"

-- | A GQL cardinality expression: one of several alternative forms
data CardinalityExpression =
  CardinalityExpressionCardinality CardinalityArgumentExpression |
  CardinalityExpressionSize ListValueExpression
  deriving (Eq, Ord, Read, Show)

_CardinalityExpression = Core.Name "openGql.grammar.CardinalityExpression"

_CardinalityExpression_cardinality = Core.Name "cardinality"

_CardinalityExpression_size = Core.Name "size"

-- | A GQL case: one of a fixed set of alternatives
data Case =
  CaseUpper |
  CaseLower
  deriving (Eq, Ord, Read, Show)

_Case = Core.Name "openGql.grammar.Case"

_Case_upper = Core.Name "upper"

_Case_lower = Core.Name "lower"

-- | A GQL case abbreviation: one of several alternative forms
data CaseAbbreviation =
  CaseAbbreviationNullIf NullIfAbbreviation |
  CaseAbbreviationCoalesce [ValueExpression]
  deriving (Eq, Ord, Read, Show)

_CaseAbbreviation = Core.Name "openGql.grammar.CaseAbbreviation"

_CaseAbbreviation_nullIf = Core.Name "nullIf"

_CaseAbbreviation_coalesce = Core.Name "coalesce"

-- | A GQL case expression: one of several alternative forms
data CaseExpression =
  CaseExpressionAbbreviation CaseAbbreviation |
  CaseExpressionSpecification CaseSpecification
  deriving (Eq, Ord, Read, Show)

_CaseExpression = Core.Name "openGql.grammar.CaseExpression"

_CaseExpression_abbreviation = Core.Name "abbreviation"

_CaseExpression_specification = Core.Name "specification"

-- | A GQL case operand: one of several alternative forms
data CaseOperand =
  CaseOperandValueExpression NonParenthesizedPrimaryValueExpression |
  CaseOperandElementReference ElementVariableReference
  deriving (Eq, Ord, Read, Show)

_CaseOperand = Core.Name "openGql.grammar.CaseOperand"

_CaseOperand_valueExpression = Core.Name "valueExpression"

_CaseOperand_elementReference = Core.Name "elementReference"

-- | A GQL case specification: one of several alternative forms
data CaseSpecification =
  CaseSpecificationSimple SimpleCase |
  CaseSpecificationSearched SearchedCase
  deriving (Eq, Ord, Read, Show)

_CaseSpecification = Core.Name "openGql.grammar.CaseSpecification"

_CaseSpecification_simple = Core.Name "simple"

_CaseSpecification_searched = Core.Name "searched"

-- | A GQL cast operand: one of several alternative forms
data CastOperand =
  CastOperandValueExpression ValueExpression |
  CastOperandNullLiteral
  deriving (Eq, Ord, Read, Show)

_CastOperand = Core.Name "openGql.grammar.CastOperand"

_CastOperand_valueExpression = Core.Name "valueExpression"

_CastOperand_nullLiteral = Core.Name "nullLiteral"

-- | A GQL cast specification
data CastSpecification =
  CastSpecification {
    castSpecificationOperand :: CastOperand,
    castSpecificationTarget :: CastTarget}
  deriving (Eq, Ord, Read, Show)

_CastSpecification = Core.Name "openGql.grammar.CastSpecification"

_CastSpecification_operand = Core.Name "operand"

_CastSpecification_target = Core.Name "target"

-- | A GQL cast target, equivalent to a value type
type CastTarget = ValueType

_CastTarget = Core.Name "openGql.grammar.CastTarget"

-- | A GQL catalog graph parent and name
data CatalogGraphParentAndName =
  CatalogGraphParentAndName {
    catalogGraphParentAndNameParentReference :: (Maybe CatalogObjectParentReference),
    catalogGraphParentAndNameGraphName :: GraphName}
  deriving (Eq, Ord, Read, Show)

_CatalogGraphParentAndName = Core.Name "openGql.grammar.CatalogGraphParentAndName"

_CatalogGraphParentAndName_parentReference = Core.Name "parentReference"

_CatalogGraphParentAndName_graphName = Core.Name "graphName"

-- | A GQL catalog graph type parent and name
data CatalogGraphTypeParentAndName =
  CatalogGraphTypeParentAndName {
    catalogGraphTypeParentAndNameParentReference :: (Maybe CatalogObjectParentReference),
    catalogGraphTypeParentAndNameGraphTypeName :: GraphTypeName}
  deriving (Eq, Ord, Read, Show)

_CatalogGraphTypeParentAndName = Core.Name "openGql.grammar.CatalogGraphTypeParentAndName"

_CatalogGraphTypeParentAndName_parentReference = Core.Name "parentReference"

_CatalogGraphTypeParentAndName_graphTypeName = Core.Name "graphTypeName"

-- | A GQL catalog object parent reference: one of several alternative forms
data CatalogObjectParentReference =
  CatalogObjectParentReferenceSchemaAndObjects SchemaAndObjects |
  CatalogObjectParentReferenceObjectsOnly [ObjectName]
  deriving (Eq, Ord, Read, Show)

_CatalogObjectParentReference = Core.Name "openGql.grammar.CatalogObjectParentReference"

_CatalogObjectParentReference_schemaAndObjects = Core.Name "schemaAndObjects"

_CatalogObjectParentReference_objectsOnly = Core.Name "objectsOnly"

-- | A GQL catalog procedure parent and name
data CatalogProcedureParentAndName =
  CatalogProcedureParentAndName {
    catalogProcedureParentAndNameParentReference :: (Maybe CatalogObjectParentReference),
    catalogProcedureParentAndNameProcedureName :: ProcedureName}
  deriving (Eq, Ord, Read, Show)

_CatalogProcedureParentAndName = Core.Name "openGql.grammar.CatalogProcedureParentAndName"

_CatalogProcedureParentAndName_parentReference = Core.Name "parentReference"

_CatalogProcedureParentAndName_procedureName = Core.Name "procedureName"

-- | A GQL catalog schema parent and name, equivalent to a absolute directory and schema
type CatalogSchemaParentAndName = AbsoluteDirectoryAndSchema

_CatalogSchemaParentAndName = Core.Name "openGql.grammar.CatalogSchemaParentAndName"

-- | A GQL ceiling function, equivalent to a numeric value expression
type CeilingFunction = NumericValueExpression

_CeilingFunction = Core.Name "openGql.grammar.CeilingFunction"

-- | A GQL char length expression, equivalent to a character string value expression
type CharLengthExpression = CharacterStringValueExpression

_CharLengthExpression = Core.Name "openGql.grammar.CharLengthExpression"

-- | A GQL char type
data CharType =
  CharType {
    charTypeFixedLength :: (Maybe FixedLength),
    charTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_CharType = Core.Name "openGql.grammar.CharType"

_CharType_fixedLength = Core.Name "fixedLength"

_CharType_notNull = Core.Name "notNull"

-- | A GQL character or byte string function: one of several alternative forms
data CharacterOrByteStringFunction =
  CharacterOrByteStringFunctionSub SubCharacterOrByteString |
  CharacterOrByteStringFunctionTrimSingle TrimSingleCharacterOrByteString |
  CharacterOrByteStringFunctionFold FoldCharacterString |
  CharacterOrByteStringFunctionTrimMultiCharacter TrimMultiCharacterCharacterString |
  CharacterOrByteStringFunctionNormalize NormalizeCharacterString
  deriving (Eq, Ord, Read, Show)

_CharacterOrByteStringFunction = Core.Name "openGql.grammar.CharacterOrByteStringFunction"

_CharacterOrByteStringFunction_sub = Core.Name "sub"

_CharacterOrByteStringFunction_trimSingle = Core.Name "trimSingle"

_CharacterOrByteStringFunction_fold = Core.Name "fold"

_CharacterOrByteStringFunction_trimMultiCharacter = Core.Name "trimMultiCharacter"

_CharacterOrByteStringFunction_normalize = Core.Name "normalize"

-- | A GQL character string literal
type CharacterStringLiteral = String

_CharacterStringLiteral = Core.Name "openGql.grammar.CharacterStringLiteral"

-- | A GQL character string type: one of several alternative forms
data CharacterStringType =
  CharacterStringTypeStringType StringType |
  CharacterStringTypeCharType CharType |
  CharacterStringTypeVarcharType VarcharType
  deriving (Eq, Ord, Read, Show)

_CharacterStringType = Core.Name "openGql.grammar.CharacterStringType"

_CharacterStringType_stringType = Core.Name "stringType"

_CharacterStringType_charType = Core.Name "charType"

_CharacterStringType_varcharType = Core.Name "varcharType"

-- | A GQL character string value expression, equivalent to a value expression
type CharacterStringValueExpression = ValueExpression

_CharacterStringValueExpression = Core.Name "openGql.grammar.CharacterStringValueExpression"

-- | A GQL closed dynamic union type alt1
data ClosedDynamicUnionTypeAlt1 =
  ClosedDynamicUnionTypeAlt1 {
    closedDynamicUnionTypeAlt1AnyValue :: (Maybe Bool),
    closedDynamicUnionTypeAlt1ValueTypes :: [ValueType]}
  deriving (Eq, Ord, Read, Show)

_ClosedDynamicUnionTypeAlt1 = Core.Name "openGql.grammar.ClosedDynamicUnionTypeAlt1"

_ClosedDynamicUnionTypeAlt1_anyValue = Core.Name "anyValue"

_ClosedDynamicUnionTypeAlt1_valueTypes = Core.Name "valueTypes"

-- | A GQL closed dynamic union type alt2
data ClosedDynamicUnionTypeAlt2 =
  ClosedDynamicUnionTypeAlt2 {
    closedDynamicUnionTypeAlt2ValueTypes :: [ValueType]}
  deriving (Eq, Ord, Read, Show)

_ClosedDynamicUnionTypeAlt2 = Core.Name "openGql.grammar.ClosedDynamicUnionTypeAlt2"

_ClosedDynamicUnionTypeAlt2_valueTypes = Core.Name "valueTypes"

-- | A GQL closed edge reference value type
data ClosedEdgeReferenceValueType =
  ClosedEdgeReferenceValueType {
    closedEdgeReferenceValueTypeEdgeTypeSpec :: EdgeTypeSpecification,
    closedEdgeReferenceValueTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_ClosedEdgeReferenceValueType = Core.Name "openGql.grammar.ClosedEdgeReferenceValueType"

_ClosedEdgeReferenceValueType_edgeTypeSpec = Core.Name "edgeTypeSpec"

_ClosedEdgeReferenceValueType_notNull = Core.Name "notNull"

-- | A GQL closed graph reference value type
data ClosedGraphReferenceValueType =
  ClosedGraphReferenceValueType {
    closedGraphReferenceValueTypeProperty :: Bool,
    closedGraphReferenceValueTypeNestedSpec :: NestedGraphTypeSpecification,
    closedGraphReferenceValueTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_ClosedGraphReferenceValueType = Core.Name "openGql.grammar.ClosedGraphReferenceValueType"

_ClosedGraphReferenceValueType_property = Core.Name "property"

_ClosedGraphReferenceValueType_nestedSpec = Core.Name "nestedSpec"

_ClosedGraphReferenceValueType_notNull = Core.Name "notNull"

-- | A GQL closed node reference value type
data ClosedNodeReferenceValueType =
  ClosedNodeReferenceValueType {
    closedNodeReferenceValueTypeNodeTypeSpec :: NodeTypeSpecification,
    closedNodeReferenceValueTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_ClosedNodeReferenceValueType = Core.Name "openGql.grammar.ClosedNodeReferenceValueType"

_ClosedNodeReferenceValueType_nodeTypeSpec = Core.Name "nodeTypeSpec"

_ClosedNodeReferenceValueType_notNull = Core.Name "notNull"

-- | A GQL commit command
type CommitCommand = ()

_CommitCommand = Core.Name "openGql.grammar.CommitCommand"

-- | A GQL common logarithm, equivalent to a numeric value expression
type CommonLogarithm = NumericValueExpression

_CommonLogarithm = Core.Name "openGql.grammar.CommonLogarithm"

-- | A GQL comp op: one of a fixed set of alternatives
data CompOp =
  CompOpEquals |
  CompOpNotEquals |
  CompOpLessThan |
  CompOpGreaterThan |
  CompOpLessThanOrEquals |
  CompOpGreaterThanOrEquals
  deriving (Eq, Ord, Read, Show)

_CompOp = Core.Name "openGql.grammar.CompOp"

_CompOp_equals = Core.Name "equals"

_CompOp_notEquals = Core.Name "notEquals"

_CompOp_lessThan = Core.Name "lessThan"

_CompOp_greaterThan = Core.Name "greaterThan"

_CompOp_lessThanOrEquals = Core.Name "lessThanOrEquals"

_CompOp_greaterThanOrEquals = Core.Name "greaterThanOrEquals"

-- | A GQL comparison expression
data ComparisonExpr =
  ComparisonExpr {
    comparisonExprValueExpression :: ValueExpression,
    comparisonExprComparison :: ComparisonPredicatePart2}
  deriving (Eq, Ord, Read, Show)

_ComparisonExpr = Core.Name "openGql.grammar.ComparisonExpr"

_ComparisonExpr_valueExpression = Core.Name "valueExpression"

_ComparisonExpr_comparison = Core.Name "comparison"

-- | A GQL comparison predicate part2
data ComparisonPredicatePart2 =
  ComparisonPredicatePart2 {
    comparisonPredicatePart2CompOp :: CompOp,
    comparisonPredicatePart2ValueExpression :: ValueExpression}
  deriving (Eq, Ord, Read, Show)

_ComparisonPredicatePart2 = Core.Name "openGql.grammar.ComparisonPredicatePart2"

_ComparisonPredicatePart2_compOp = Core.Name "compOp"

_ComparisonPredicatePart2_valueExpression = Core.Name "valueExpression"

-- | A GQL composite query expression: one of several alternative forms
data CompositeQueryExpression =
  CompositeQueryExpressionSimple CompositeQueryExpressionConjunction |
  CompositeQueryExpressionPrimary CompositeQueryPrimary
  deriving (Eq, Ord, Read, Show)

_CompositeQueryExpression = Core.Name "openGql.grammar.CompositeQueryExpression"

_CompositeQueryExpression_simple = Core.Name "simple"

_CompositeQueryExpression_primary = Core.Name "primary"

-- | A GQL composite query expression conjunction
data CompositeQueryExpressionConjunction =
  CompositeQueryExpressionConjunction {
    compositeQueryExpressionConjunctionLeft :: CompositeQueryExpression,
    compositeQueryExpressionConjunctionConjunction :: QueryConjunction,
    compositeQueryExpressionConjunctionRight :: CompositeQueryPrimary}
  deriving (Eq, Ord, Read, Show)

_CompositeQueryExpressionConjunction = Core.Name "openGql.grammar.CompositeQueryExpressionConjunction"

_CompositeQueryExpressionConjunction_left = Core.Name "left"

_CompositeQueryExpressionConjunction_conjunction = Core.Name "conjunction"

_CompositeQueryExpressionConjunction_right = Core.Name "right"

-- | A GQL composite query primary, equivalent to a linear query statement
type CompositeQueryPrimary = LinearQueryStatement

_CompositeQueryPrimary = Core.Name "openGql.grammar.CompositeQueryPrimary"

-- | A GQL composite query statement, equivalent to a composite query expression
type CompositeQueryStatement = CompositeQueryExpression

_CompositeQueryStatement = Core.Name "openGql.grammar.CompositeQueryStatement"

-- | A GQL concatenation expression
data ConcatenationExpr =
  ConcatenationExpr {
    concatenationExprLeft :: ValueExpression,
    concatenationExprRight :: ValueExpression}
  deriving (Eq, Ord, Read, Show)

_ConcatenationExpr = Core.Name "openGql.grammar.ConcatenationExpr"

_ConcatenationExpr_left = Core.Name "left"

_ConcatenationExpr_right = Core.Name "right"

-- | A GQL conjunction label expression
data ConjunctionLabelExpression =
  ConjunctionLabelExpression {
    conjunctionLabelExpressionLeft :: LabelExpression,
    conjunctionLabelExpressionRight :: LabelExpression}
  deriving (Eq, Ord, Read, Show)

_ConjunctionLabelExpression = Core.Name "openGql.grammar.ConjunctionLabelExpression"

_ConjunctionLabelExpression_left = Core.Name "left"

_ConjunctionLabelExpression_right = Core.Name "right"

-- | A GQL conjunctive expression
data ConjunctiveExpr =
  ConjunctiveExpr {
    conjunctiveExprLeft :: ValueExpression,
    conjunctiveExprRight :: ValueExpression}
  deriving (Eq, Ord, Read, Show)

_ConjunctiveExpr = Core.Name "openGql.grammar.ConjunctiveExpr"

_ConjunctiveExpr_left = Core.Name "left"

_ConjunctiveExpr_right = Core.Name "right"

-- | A GQL connector pointing right: one of a fixed set of alternatives
data ConnectorPointingRight =
  ConnectorPointingRightTo |
  ConnectorPointingRightRightArrow
  deriving (Eq, Ord, Read, Show)

_ConnectorPointingRight = Core.Name "openGql.grammar.ConnectorPointingRight"

_ConnectorPointingRight_to = Core.Name "to"

_ConnectorPointingRight_rightArrow = Core.Name "rightArrow"

-- | A GQL connector undirected: one of a fixed set of alternatives
data ConnectorUndirected =
  ConnectorUndirectedTo |
  ConnectorUndirectedTilde
  deriving (Eq, Ord, Read, Show)

_ConnectorUndirected = Core.Name "openGql.grammar.ConnectorUndirected"

_ConnectorUndirected_to = Core.Name "to"

_ConnectorUndirected_tilde = Core.Name "tilde"

-- | A GQL copy of graph type, equivalent to a graph type reference
type CopyOfGraphType = GraphTypeReference

_CopyOfGraphType = Core.Name "openGql.grammar.CopyOfGraphType"

-- | A GQL counted shortest group search
data CountedShortestGroupSearch =
  CountedShortestGroupSearch {
    countedShortestGroupSearchNumberOfGroups :: (Maybe NumberOfGroups),
    countedShortestGroupSearchMode :: (Maybe PathMode),
    countedShortestGroupSearchOrPaths :: (Maybe PathOrPaths),
    countedShortestGroupSearchGroups :: Bool}
  deriving (Eq, Ord, Read, Show)

_CountedShortestGroupSearch = Core.Name "openGql.grammar.CountedShortestGroupSearch"

_CountedShortestGroupSearch_numberOfGroups = Core.Name "numberOfGroups"

_CountedShortestGroupSearch_mode = Core.Name "mode"

_CountedShortestGroupSearch_orPaths = Core.Name "orPaths"

_CountedShortestGroupSearch_groups = Core.Name "groups"

-- | A GQL counted shortest path search
data CountedShortestPathSearch =
  CountedShortestPathSearch {
    countedShortestPathSearchNumberOfPaths :: NumberOfPaths,
    countedShortestPathSearchMode :: (Maybe PathMode),
    countedShortestPathSearchOrPaths :: (Maybe PathOrPaths)}
  deriving (Eq, Ord, Read, Show)

_CountedShortestPathSearch = Core.Name "openGql.grammar.CountedShortestPathSearch"

_CountedShortestPathSearch_numberOfPaths = Core.Name "numberOfPaths"

_CountedShortestPathSearch_mode = Core.Name "mode"

_CountedShortestPathSearch_orPaths = Core.Name "orPaths"

-- | A GQL create graph option: one of several alternative forms
data CreateGraphOption =
  CreateGraphOptionGraphIfNotExists Bool |
  CreateGraphOptionOrReplace
  deriving (Eq, Ord, Read, Show)

_CreateGraphOption = Core.Name "openGql.grammar.CreateGraphOption"

_CreateGraphOption_graphIfNotExists = Core.Name "graphIfNotExists"

_CreateGraphOption_orReplace = Core.Name "orReplace"

-- | A GQL create graph statement
data CreateGraphStatement =
  CreateGraphStatement {
    createGraphStatementCreateOption :: CreateGraphOption,
    createGraphStatementParentAndName :: CatalogGraphParentAndName,
    createGraphStatementType :: GraphTypeOption,
    createGraphStatementSource :: (Maybe GraphSource)}
  deriving (Eq, Ord, Read, Show)

_CreateGraphStatement = Core.Name "openGql.grammar.CreateGraphStatement"

_CreateGraphStatement_createOption = Core.Name "createOption"

_CreateGraphStatement_parentAndName = Core.Name "parentAndName"

_CreateGraphStatement_type = Core.Name "type"

_CreateGraphStatement_source = Core.Name "source"

-- | A GQL create graph type option: one of several alternative forms
data CreateGraphTypeOption =
  CreateGraphTypeOptionTypeIfNotExists Bool |
  CreateGraphTypeOptionOrReplace
  deriving (Eq, Ord, Read, Show)

_CreateGraphTypeOption = Core.Name "openGql.grammar.CreateGraphTypeOption"

_CreateGraphTypeOption_typeIfNotExists = Core.Name "typeIfNotExists"

_CreateGraphTypeOption_orReplace = Core.Name "orReplace"

-- | A GQL create graph type statement
data CreateGraphTypeStatement =
  CreateGraphTypeStatement {
    createGraphTypeStatementCreateOption :: CreateGraphTypeOption,
    createGraphTypeStatementParentAndName :: CatalogGraphTypeParentAndName,
    createGraphTypeStatementSource :: GraphTypeSource}
  deriving (Eq, Ord, Read, Show)

_CreateGraphTypeStatement = Core.Name "openGql.grammar.CreateGraphTypeStatement"

_CreateGraphTypeStatement_createOption = Core.Name "createOption"

_CreateGraphTypeStatement_parentAndName = Core.Name "parentAndName"

_CreateGraphTypeStatement_source = Core.Name "source"

-- | A GQL create schema statement
data CreateSchemaStatement =
  CreateSchemaStatement {
    createSchemaStatementIfNotExists :: Bool,
    createSchemaStatementParentAndName :: CatalogSchemaParentAndName}
  deriving (Eq, Ord, Read, Show)

_CreateSchemaStatement = Core.Name "openGql.grammar.CreateSchemaStatement"

_CreateSchemaStatement_ifNotExists = Core.Name "ifNotExists"

_CreateSchemaStatement_parentAndName = Core.Name "parentAndName"

-- | A GQL current graph: one of a fixed set of alternatives
data CurrentGraph =
  CurrentGraphGraph |
  CurrentGraphPropertyGraph
  deriving (Eq, Ord, Read, Show)

_CurrentGraph = Core.Name "openGql.grammar.CurrentGraph"

_CurrentGraph_graph = Core.Name "graph"

_CurrentGraph_propertyGraph = Core.Name "propertyGraph"

-- | A GQL date function: one of several alternative forms
data DateFunction =
  DateFunctionCurrentDate |
  DateFunctionDateWithParams (Maybe DateFunctionParameters)
  deriving (Eq, Ord, Read, Show)

_DateFunction = Core.Name "openGql.grammar.DateFunction"

_DateFunction_currentDate = Core.Name "currentDate"

_DateFunction_dateWithParams = Core.Name "dateWithParams"

-- | A GQL date function parameters: one of several alternative forms
data DateFunctionParameters =
  DateFunctionParametersDateString DateString |
  DateFunctionParametersRecordConstructor RecordConstructor
  deriving (Eq, Ord, Read, Show)

_DateFunctionParameters = Core.Name "openGql.grammar.DateFunctionParameters"

_DateFunctionParameters_dateString = Core.Name "dateString"

_DateFunctionParameters_recordConstructor = Core.Name "recordConstructor"

-- | A GQL date literal, equivalent to a date string
type DateLiteral = DateString

_DateLiteral = Core.Name "openGql.grammar.DateLiteral"

-- | A GQL date string, equivalent to a character string literal
type DateString = CharacterStringLiteral

_DateString = Core.Name "openGql.grammar.DateString"

-- | A GQL date type
data DateType =
  DateType {
    dateTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_DateType = Core.Name "openGql.grammar.DateType"

_DateType_notNull = Core.Name "notNull"

-- | A GQL datetime function: one of several alternative forms
data DatetimeFunction =
  DatetimeFunctionCurrentTimestamp |
  DatetimeFunctionZonedDatetimeWithParams (Maybe DatetimeFunctionParameters)
  deriving (Eq, Ord, Read, Show)

_DatetimeFunction = Core.Name "openGql.grammar.DatetimeFunction"

_DatetimeFunction_currentTimestamp = Core.Name "currentTimestamp"

_DatetimeFunction_zonedDatetimeWithParams = Core.Name "zonedDatetimeWithParams"

-- | A GQL datetime function parameters: one of several alternative forms
data DatetimeFunctionParameters =
  DatetimeFunctionParametersDatetimeString DatetimeString |
  DatetimeFunctionParametersRecordConstructor RecordConstructor
  deriving (Eq, Ord, Read, Show)

_DatetimeFunctionParameters = Core.Name "openGql.grammar.DatetimeFunctionParameters"

_DatetimeFunctionParameters_datetimeString = Core.Name "datetimeString"

_DatetimeFunctionParameters_recordConstructor = Core.Name "recordConstructor"

-- | A GQL datetime literal, equivalent to a datetime string
type DatetimeLiteral = DatetimeString

_DatetimeLiteral = Core.Name "openGql.grammar.DatetimeLiteral"

-- | A GQL datetime string, equivalent to a character string literal
type DatetimeString = CharacterStringLiteral

_DatetimeString = Core.Name "openGql.grammar.DatetimeString"

-- | A GQL datetime subtraction
data DatetimeSubtraction =
  DatetimeSubtraction {
    datetimeSubtractionParameters :: DatetimeSubtractionParameters,
    datetimeSubtractionTemporalDurationQualifier :: (Maybe TemporalDurationQualifier)}
  deriving (Eq, Ord, Read, Show)

_DatetimeSubtraction = Core.Name "openGql.grammar.DatetimeSubtraction"

_DatetimeSubtraction_parameters = Core.Name "parameters"

_DatetimeSubtraction_temporalDurationQualifier = Core.Name "temporalDurationQualifier"

-- | A GQL datetime subtraction parameters
data DatetimeSubtractionParameters =
  DatetimeSubtractionParameters {
    datetimeSubtractionParametersExpression1 :: DatetimeValueExpression1,
    datetimeSubtractionParametersExpression2 :: DatetimeValueExpression2}
  deriving (Eq, Ord, Read, Show)

_DatetimeSubtractionParameters = Core.Name "openGql.grammar.DatetimeSubtractionParameters"

_DatetimeSubtractionParameters_expression1 = Core.Name "expression1"

_DatetimeSubtractionParameters_expression2 = Core.Name "expression2"

-- | A GQL datetime type: one of several alternative forms
data DatetimeType =
  DatetimeTypeZonedDatetime ZonedDatetimeType |
  DatetimeTypeTimestampWithTimeZone TimestampWithTimeZoneType
  deriving (Eq, Ord, Read, Show)

_DatetimeType = Core.Name "openGql.grammar.DatetimeType"

_DatetimeType_zonedDatetime = Core.Name "zonedDatetime"

_DatetimeType_timestampWithTimeZone = Core.Name "timestampWithTimeZone"

-- | A GQL datetime value expression, equivalent to a value expression
type DatetimeValueExpression = ValueExpression

_DatetimeValueExpression = Core.Name "openGql.grammar.DatetimeValueExpression"

-- | A GQL datetime value expression1, equivalent to a datetime value expression
type DatetimeValueExpression1 = DatetimeValueExpression

_DatetimeValueExpression1 = Core.Name "openGql.grammar.DatetimeValueExpression1"

-- | A GQL datetime value expression2, equivalent to a datetime value expression
type DatetimeValueExpression2 = DatetimeValueExpression

_DatetimeValueExpression2 = Core.Name "openGql.grammar.DatetimeValueExpression2"

-- | A GQL datetime value function: one of several alternative forms
data DatetimeValueFunction =
  DatetimeValueFunctionDateFunction DateFunction |
  DatetimeValueFunctionTimeFunction TimeFunction |
  DatetimeValueFunctionDatetimeFunction DatetimeFunction |
  DatetimeValueFunctionLocaltimeFunction LocaltimeFunction |
  DatetimeValueFunctionLocaldatetimeFunction LocaldatetimeFunction
  deriving (Eq, Ord, Read, Show)

_DatetimeValueFunction = Core.Name "openGql.grammar.DatetimeValueFunction"

_DatetimeValueFunction_dateFunction = Core.Name "dateFunction"

_DatetimeValueFunction_timeFunction = Core.Name "timeFunction"

_DatetimeValueFunction_datetimeFunction = Core.Name "datetimeFunction"

_DatetimeValueFunction_localtimeFunction = Core.Name "localtimeFunction"

_DatetimeValueFunction_localdatetimeFunction = Core.Name "localdatetimeFunction"

-- | An optional GQL decimal exact numeric type
type DecimalExactNumericType = (Maybe PrecisionAndScale)

_DecimalExactNumericType = Core.Name "openGql.grammar.DecimalExactNumericType"

-- | A GQL delete item, equivalent to a value expression
type DeleteItem = ValueExpression

_DeleteItem = Core.Name "openGql.grammar.DeleteItem"

-- | A list of GQL delete item list elements
type DeleteItemList = [DeleteItem]

_DeleteItemList = Core.Name "openGql.grammar.DeleteItemList"

-- | A GQL delete statement
data DeleteStatement =
  DeleteStatement {
    deleteStatementDetach :: (Maybe DetachOption),
    deleteStatementItems :: DeleteItemList}
  deriving (Eq, Ord, Read, Show)

_DeleteStatement = Core.Name "openGql.grammar.DeleteStatement"

_DeleteStatement_detach = Core.Name "detach"

_DeleteStatement_items = Core.Name "items"

-- | A GQL delimited binding table name
type DelimitedBindingTableName = String

_DelimitedBindingTableName = Core.Name "openGql.grammar.DelimitedBindingTableName"

-- | A GQL delimited graph name
type DelimitedGraphName = String

_DelimitedGraphName = Core.Name "openGql.grammar.DelimitedGraphName"

-- | A GQL dependent value expression
data DependentValueExpression =
  DependentValueExpression {
    dependentValueExpressionSetQuantifier :: (Maybe SetQuantifier),
    dependentValueExpressionNumericValue :: NumericValueExpression}
  deriving (Eq, Ord, Read, Show)

_DependentValueExpression = Core.Name "openGql.grammar.DependentValueExpression"

_DependentValueExpression_setQuantifier = Core.Name "setQuantifier"

_DependentValueExpression_numericValue = Core.Name "numericValue"

-- | A GQL destination node type alias
type DestinationNodeTypeAlias = String

_DestinationNodeTypeAlias = Core.Name "openGql.grammar.DestinationNodeTypeAlias"

-- | A GQL destination node type reference: one of several alternative forms
data DestinationNodeTypeReference =
  DestinationNodeTypeReferenceAlias DestinationNodeTypeAlias |
  DestinationNodeTypeReferenceFiller (Maybe NodeTypeFiller)
  deriving (Eq, Ord, Read, Show)

_DestinationNodeTypeReference = Core.Name "openGql.grammar.DestinationNodeTypeReference"

_DestinationNodeTypeReference_alias = Core.Name "alias"

_DestinationNodeTypeReference_filler = Core.Name "filler"

-- | A GQL destination predicate
data DestinationPredicate =
  DestinationPredicate {
    destinationPredicateNodeReference :: NodeReference,
    destinationPredicateNot :: Bool,
    destinationPredicateDestinationOf :: EdgeReference}
  deriving (Eq, Ord, Read, Show)

_DestinationPredicate = Core.Name "openGql.grammar.DestinationPredicate"

_DestinationPredicate_nodeReference = Core.Name "nodeReference"

_DestinationPredicate_not = Core.Name "not"

_DestinationPredicate_destinationOf = Core.Name "destinationOf"

-- | A GQL detach option: one of a fixed set of alternatives
data DetachOption =
  DetachOptionDetach |
  DetachOptionNoDetach
  deriving (Eq, Ord, Read, Show)

_DetachOption = Core.Name "openGql.grammar.DetachOption"

_DetachOption_detach = Core.Name "detach"

_DetachOption_noDetach = Core.Name "noDetach"

-- | A GQL different edges match mode, equivalent to a edge bindings or edges
type DifferentEdgesMatchMode = EdgeBindingsOrEdges

_DifferentEdgesMatchMode = Core.Name "openGql.grammar.DifferentEdgesMatchMode"

-- | A GQL directed predicate
data DirectedPredicate =
  DirectedPredicate {
    directedPredicateElementVariableReference :: ElementVariableReference,
    directedPredicateDirectedPart :: DirectedPredicatePart2}
  deriving (Eq, Ord, Read, Show)

_DirectedPredicate = Core.Name "openGql.grammar.DirectedPredicate"

_DirectedPredicate_elementVariableReference = Core.Name "elementVariableReference"

_DirectedPredicate_directedPart = Core.Name "directedPart"

-- | A GQL directed predicate part2
data DirectedPredicatePart2 =
  DirectedPredicatePart2 {
    directedPredicatePart2Not :: Bool}
  deriving (Eq, Ord, Read, Show)

_DirectedPredicatePart2 = Core.Name "openGql.grammar.DirectedPredicatePart2"

_DirectedPredicatePart2_not = Core.Name "not"

-- | A GQL directory name
type DirectoryName = String

_DirectoryName = Core.Name "openGql.grammar.DirectoryName"

-- | A GQL disjunction label expression
data DisjunctionLabelExpression =
  DisjunctionLabelExpression {
    disjunctionLabelExpressionLeft :: LabelExpression,
    disjunctionLabelExpressionRight :: LabelExpression}
  deriving (Eq, Ord, Read, Show)

_DisjunctionLabelExpression = Core.Name "openGql.grammar.DisjunctionLabelExpression"

_DisjunctionLabelExpression_left = Core.Name "left"

_DisjunctionLabelExpression_right = Core.Name "right"

-- | A GQL disjunctive expression
data DisjunctiveExpr =
  DisjunctiveExpr {
    disjunctiveExprLeft :: ValueExpression,
    disjunctiveExprOperator :: DisjunctiveOperator,
    disjunctiveExprRight :: ValueExpression}
  deriving (Eq, Ord, Read, Show)

_DisjunctiveExpr = Core.Name "openGql.grammar.DisjunctiveExpr"

_DisjunctiveExpr_left = Core.Name "left"

_DisjunctiveExpr_operator = Core.Name "operator"

_DisjunctiveExpr_right = Core.Name "right"

-- | A GQL disjunctive operator: one of a fixed set of alternatives
data DisjunctiveOperator =
  DisjunctiveOperatorOr |
  DisjunctiveOperatorXor
  deriving (Eq, Ord, Read, Show)

_DisjunctiveOperator = Core.Name "openGql.grammar.DisjunctiveOperator"

_DisjunctiveOperator_or = Core.Name "or"

_DisjunctiveOperator_xor = Core.Name "xor"

-- | A GQL double type with precision
data DoubleTypeWithPrecision =
  DoubleTypeWithPrecision {
    doubleTypeWithPrecisionPrecision :: Bool,
    doubleTypeWithPrecisionNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_DoubleTypeWithPrecision = Core.Name "openGql.grammar.DoubleTypeWithPrecision"

_DoubleTypeWithPrecision_precision = Core.Name "precision"

_DoubleTypeWithPrecision_notNull = Core.Name "notNull"

-- | A GQL drop graph statement
data DropGraphStatement =
  DropGraphStatement {
    dropGraphStatementIfExists :: Bool,
    dropGraphStatementParentAndName :: CatalogGraphParentAndName}
  deriving (Eq, Ord, Read, Show)

_DropGraphStatement = Core.Name "openGql.grammar.DropGraphStatement"

_DropGraphStatement_ifExists = Core.Name "ifExists"

_DropGraphStatement_parentAndName = Core.Name "parentAndName"

-- | A GQL drop graph type statement
data DropGraphTypeStatement =
  DropGraphTypeStatement {
    dropGraphTypeStatementIfExists :: Bool,
    dropGraphTypeStatementParentAndName :: CatalogGraphTypeParentAndName}
  deriving (Eq, Ord, Read, Show)

_DropGraphTypeStatement = Core.Name "openGql.grammar.DropGraphTypeStatement"

_DropGraphTypeStatement_ifExists = Core.Name "ifExists"

_DropGraphTypeStatement_parentAndName = Core.Name "parentAndName"

-- | A GQL drop schema statement
data DropSchemaStatement =
  DropSchemaStatement {
    dropSchemaStatementIfExists :: Bool,
    dropSchemaStatementParentAndName :: CatalogSchemaParentAndName}
  deriving (Eq, Ord, Read, Show)

_DropSchemaStatement = Core.Name "openGql.grammar.DropSchemaStatement"

_DropSchemaStatement_ifExists = Core.Name "ifExists"

_DropSchemaStatement_parentAndName = Core.Name "parentAndName"

-- | A GQL duration function, equivalent to a duration function parameters
type DurationFunction = DurationFunctionParameters

_DurationFunction = Core.Name "openGql.grammar.DurationFunction"

-- | A GQL duration function parameters: one of several alternative forms
data DurationFunctionParameters =
  DurationFunctionParametersDurationString DurationString |
  DurationFunctionParametersRecordConstructor RecordConstructor
  deriving (Eq, Ord, Read, Show)

_DurationFunctionParameters = Core.Name "openGql.grammar.DurationFunctionParameters"

_DurationFunctionParameters_durationString = Core.Name "durationString"

_DurationFunctionParameters_recordConstructor = Core.Name "recordConstructor"

-- | A GQL duration literal, equivalent to a duration string
type DurationLiteral = DurationString

_DurationLiteral = Core.Name "openGql.grammar.DurationLiteral"

-- | A GQL duration string, equivalent to a character string literal
type DurationString = CharacterStringLiteral

_DurationString = Core.Name "openGql.grammar.DurationString"

-- | A GQL duration value expression, equivalent to a value expression
type DurationValueExpression = ValueExpression

_DurationValueExpression = Core.Name "openGql.grammar.DurationValueExpression"

-- | A GQL duration value function: one of several alternative forms
data DurationValueFunction =
  DurationValueFunctionDurationFunction DurationFunction |
  DurationValueFunctionAbsoluteValue AbsoluteValueExpression
  deriving (Eq, Ord, Read, Show)

_DurationValueFunction = Core.Name "openGql.grammar.DurationValueFunction"

_DurationValueFunction_durationFunction = Core.Name "durationFunction"

_DurationValueFunction_absoluteValue = Core.Name "absoluteValue"

-- | A GQL dynamic parameter specification, equivalent to a parameter name
type DynamicParameterSpecification = ParameterName

_DynamicParameterSpecification = Core.Name "openGql.grammar.DynamicParameterSpecification"

-- | A GQL dynamic property value type
data DynamicPropertyValueType =
  DynamicPropertyValueType {
    dynamicPropertyValueTypeAny :: (Maybe Bool),
    dynamicPropertyValueTypeProperty :: (),
    dynamicPropertyValueTypeValue :: (),
    dynamicPropertyValueTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_DynamicPropertyValueType = Core.Name "openGql.grammar.DynamicPropertyValueType"

_DynamicPropertyValueType_any = Core.Name "any"

_DynamicPropertyValueType_property = Core.Name "property"

_DynamicPropertyValueType_value = Core.Name "value"

_DynamicPropertyValueType_notNull = Core.Name "notNull"

-- | A GQL edge bindings or edges: one of several alternative forms
data EdgeBindingsOrEdges =
  EdgeBindingsOrEdgesEdgeBindings Bool |
  EdgeBindingsOrEdgesEdges
  deriving (Eq, Ord, Read, Show)

_EdgeBindingsOrEdges = Core.Name "openGql.grammar.EdgeBindingsOrEdges"

_EdgeBindingsOrEdges_edgeBindings = Core.Name "edgeBindings"

_EdgeBindingsOrEdges_edges = Core.Name "edges"

-- | A GQL edge key label set with content
data EdgeKeyLabelSetWithContent =
  EdgeKeyLabelSetWithContent {
    edgeKeyLabelSetWithContentKeyLabelSet :: EdgeTypeKeyLabelSet,
    edgeKeyLabelSetWithContentImpliedContent :: (Maybe EdgeTypeImpliedContent)}
  deriving (Eq, Ord, Read, Show)

_EdgeKeyLabelSetWithContent = Core.Name "openGql.grammar.EdgeKeyLabelSetWithContent"

_EdgeKeyLabelSetWithContent_keyLabelSet = Core.Name "keyLabelSet"

_EdgeKeyLabelSetWithContent_impliedContent = Core.Name "impliedContent"

-- | A GQL edge kind: one of a fixed set of alternatives
data EdgeKind =
  EdgeKindDirected |
  EdgeKindUndirected
  deriving (Eq, Ord, Read, Show)

_EdgeKind = Core.Name "openGql.grammar.EdgeKind"

_EdgeKind_directed = Core.Name "directed"

_EdgeKind_undirected = Core.Name "undirected"

-- | A GQL edge kind and synonym
data EdgeKindAndSynonym =
  EdgeKindAndSynonym {
    edgeKindAndSynonymKind :: (Maybe EdgeKind),
    edgeKindAndSynonymSynonym :: EdgeSynonym,
    edgeKindAndSynonymTypeName :: (Maybe EdgeTypeName)}
  deriving (Eq, Ord, Read, Show)

_EdgeKindAndSynonym = Core.Name "openGql.grammar.EdgeKindAndSynonym"

_EdgeKindAndSynonym_kind = Core.Name "kind"

_EdgeKindAndSynonym_synonym = Core.Name "synonym"

_EdgeKindAndSynonym_typeName = Core.Name "typeName"

-- | A GQL edge label set with properties
data EdgeLabelSetWithProperties =
  EdgeLabelSetWithProperties {
    edgeLabelSetWithPropertiesLabelSet :: EdgeTypeLabelSet,
    edgeLabelSetWithPropertiesPropertyTypes :: EdgeTypePropertyTypes}
  deriving (Eq, Ord, Read, Show)

_EdgeLabelSetWithProperties = Core.Name "openGql.grammar.EdgeLabelSetWithProperties"

_EdgeLabelSetWithProperties_labelSet = Core.Name "labelSet"

_EdgeLabelSetWithProperties_propertyTypes = Core.Name "propertyTypes"

-- | A GQL edge pattern: one of several alternative forms
data EdgePattern =
  EdgePatternFullEdge FullEdgePattern |
  EdgePatternAbbreviatedEdge AbbreviatedEdgePattern
  deriving (Eq, Ord, Read, Show)

_EdgePattern = Core.Name "openGql.grammar.EdgePattern"

_EdgePattern_fullEdge = Core.Name "fullEdge"

_EdgePattern_abbreviatedEdge = Core.Name "abbreviatedEdge"

-- | A GQL edge reference, equivalent to a element variable reference
type EdgeReference = ElementVariableReference

_EdgeReference = Core.Name "openGql.grammar.EdgeReference"

-- | A GQL edge reference value expression, equivalent to a primary value expression
type EdgeReferenceValueExpression = PrimaryValueExpression

_EdgeReferenceValueExpression = Core.Name "openGql.grammar.EdgeReferenceValueExpression"

-- | A GQL edge reference value type: one of several alternative forms
data EdgeReferenceValueType =
  EdgeReferenceValueTypeOpen OpenEdgeReferenceValueType |
  EdgeReferenceValueTypeClosed ClosedEdgeReferenceValueType
  deriving (Eq, Ord, Read, Show)

_EdgeReferenceValueType = Core.Name "openGql.grammar.EdgeReferenceValueType"

_EdgeReferenceValueType_open = Core.Name "open"

_EdgeReferenceValueType_closed = Core.Name "closed"

-- | A GQL edge synonym: one of a fixed set of alternatives
data EdgeSynonym =
  EdgeSynonymEdge |
  EdgeSynonymRelationship
  deriving (Eq, Ord, Read, Show)

_EdgeSynonym = Core.Name "openGql.grammar.EdgeSynonym"

_EdgeSynonym_edge = Core.Name "edge"

_EdgeSynonym_relationship = Core.Name "relationship"

-- | A GQL edge type filler: one of several alternative forms
data EdgeTypeFiller =
  EdgeTypeFillerKeyLabelSetWithContent EdgeKeyLabelSetWithContent |
  EdgeTypeFillerImpliedContent EdgeTypeImpliedContent
  deriving (Eq, Ord, Read, Show)

_EdgeTypeFiller = Core.Name "openGql.grammar.EdgeTypeFiller"

_EdgeTypeFiller_keyLabelSetWithContent = Core.Name "keyLabelSetWithContent"

_EdgeTypeFiller_impliedContent = Core.Name "impliedContent"

-- | A GQL edge type implied content: one of several alternative forms
data EdgeTypeImpliedContent =
  EdgeTypeImpliedContentLabelSet EdgeTypeLabelSet |
  EdgeTypeImpliedContentPropertyTypes EdgeTypePropertyTypes |
  EdgeTypeImpliedContentLabelSetWithProperties EdgeLabelSetWithProperties
  deriving (Eq, Ord, Read, Show)

_EdgeTypeImpliedContent = Core.Name "openGql.grammar.EdgeTypeImpliedContent"

_EdgeTypeImpliedContent_labelSet = Core.Name "labelSet"

_EdgeTypeImpliedContent_propertyTypes = Core.Name "propertyTypes"

_EdgeTypeImpliedContent_labelSetWithProperties = Core.Name "labelSetWithProperties"

-- | An optional GQL edge type key label set
type EdgeTypeKeyLabelSet = (Maybe LabelSetPhrase)

_EdgeTypeKeyLabelSet = Core.Name "openGql.grammar.EdgeTypeKeyLabelSet"

-- | A GQL edge type label set, equivalent to a label set phrase
type EdgeTypeLabelSet = LabelSetPhrase

_EdgeTypeLabelSet = Core.Name "openGql.grammar.EdgeTypeLabelSet"

-- | A GQL edge type name
type EdgeTypeName = String

_EdgeTypeName = Core.Name "openGql.grammar.EdgeTypeName"

-- | A GQL edge type name with filler
data EdgeTypeNameWithFiller =
  EdgeTypeNameWithFiller {
    edgeTypeNameWithFillerTypeName :: EdgeTypeName,
    edgeTypeNameWithFillerFiller :: (Maybe EdgeTypeFiller)}
  deriving (Eq, Ord, Read, Show)

_EdgeTypeNameWithFiller = Core.Name "openGql.grammar.EdgeTypeNameWithFiller"

_EdgeTypeNameWithFiller_typeName = Core.Name "typeName"

_EdgeTypeNameWithFiller_filler = Core.Name "filler"

-- | A GQL edge type pattern
data EdgeTypePattern =
  EdgeTypePattern {
    edgeTypePatternKindAndSynonym :: (Maybe EdgeKindAndSynonym),
    edgeTypePatternPatternType :: EdgeTypePatternType}
  deriving (Eq, Ord, Read, Show)

_EdgeTypePattern = Core.Name "openGql.grammar.EdgeTypePattern"

_EdgeTypePattern_kindAndSynonym = Core.Name "kindAndSynonym"

_EdgeTypePattern_patternType = Core.Name "patternType"

-- | A GQL edge type pattern directed: one of several alternative forms
data EdgeTypePatternDirected =
  EdgeTypePatternDirectedPointingRight EdgeTypePatternPointingRight |
  EdgeTypePatternDirectedPointingLeft EdgeTypePatternPointingLeft
  deriving (Eq, Ord, Read, Show)

_EdgeTypePatternDirected = Core.Name "openGql.grammar.EdgeTypePatternDirected"

_EdgeTypePatternDirected_pointingRight = Core.Name "pointingRight"

_EdgeTypePatternDirected_pointingLeft = Core.Name "pointingLeft"

-- | A GQL edge type pattern pointing left
data EdgeTypePatternPointingLeft =
  EdgeTypePatternPointingLeft {
    edgeTypePatternPointingLeftDestination :: DestinationNodeTypeReference,
    edgeTypePatternPointingLeftArc :: ArcTypePointingLeft,
    edgeTypePatternPointingLeftSource :: SourceNodeTypeReference}
  deriving (Eq, Ord, Read, Show)

_EdgeTypePatternPointingLeft = Core.Name "openGql.grammar.EdgeTypePatternPointingLeft"

_EdgeTypePatternPointingLeft_destination = Core.Name "destination"

_EdgeTypePatternPointingLeft_arc = Core.Name "arc"

_EdgeTypePatternPointingLeft_source = Core.Name "source"

-- | A GQL edge type pattern pointing right
data EdgeTypePatternPointingRight =
  EdgeTypePatternPointingRight {
    edgeTypePatternPointingRightSource :: SourceNodeTypeReference,
    edgeTypePatternPointingRightArc :: ArcTypePointingRight,
    edgeTypePatternPointingRightDestination :: DestinationNodeTypeReference}
  deriving (Eq, Ord, Read, Show)

_EdgeTypePatternPointingRight = Core.Name "openGql.grammar.EdgeTypePatternPointingRight"

_EdgeTypePatternPointingRight_source = Core.Name "source"

_EdgeTypePatternPointingRight_arc = Core.Name "arc"

_EdgeTypePatternPointingRight_destination = Core.Name "destination"

-- | A GQL edge type pattern type: one of several alternative forms
data EdgeTypePatternType =
  EdgeTypePatternTypeDirected EdgeTypePatternDirected |
  EdgeTypePatternTypeUndirected EdgeTypePatternUndirected
  deriving (Eq, Ord, Read, Show)

_EdgeTypePatternType = Core.Name "openGql.grammar.EdgeTypePatternType"

_EdgeTypePatternType_directed = Core.Name "directed"

_EdgeTypePatternType_undirected = Core.Name "undirected"

-- | A GQL edge type pattern undirected
data EdgeTypePatternUndirected =
  EdgeTypePatternUndirected {
    edgeTypePatternUndirectedSource :: SourceNodeTypeReference,
    edgeTypePatternUndirectedArc :: ArcTypeUndirected,
    edgeTypePatternUndirectedDestination :: DestinationNodeTypeReference}
  deriving (Eq, Ord, Read, Show)

_EdgeTypePatternUndirected = Core.Name "openGql.grammar.EdgeTypePatternUndirected"

_EdgeTypePatternUndirected_source = Core.Name "source"

_EdgeTypePatternUndirected_arc = Core.Name "arc"

_EdgeTypePatternUndirected_destination = Core.Name "destination"

-- | A GQL edge type phrase
data EdgeTypePhrase =
  EdgeTypePhrase {
    edgeTypePhraseKind :: EdgeKind,
    edgeTypePhraseSynonym :: EdgeSynonym,
    edgeTypePhraseTypeNameAndFiller :: EdgeTypePhraseFiller,
    edgeTypePhraseEndpointPair :: EndpointPairPhrase}
  deriving (Eq, Ord, Read, Show)

_EdgeTypePhrase = Core.Name "openGql.grammar.EdgeTypePhrase"

_EdgeTypePhrase_kind = Core.Name "kind"

_EdgeTypePhrase_synonym = Core.Name "synonym"

_EdgeTypePhrase_typeNameAndFiller = Core.Name "typeNameAndFiller"

_EdgeTypePhrase_endpointPair = Core.Name "endpointPair"

-- | A GQL edge type phrase filler: one of several alternative forms
data EdgeTypePhraseFiller =
  EdgeTypePhraseFillerTypeNameWithFiller EdgeTypeNameWithFiller |
  EdgeTypePhraseFillerFillerOnly EdgeTypeFiller
  deriving (Eq, Ord, Read, Show)

_EdgeTypePhraseFiller = Core.Name "openGql.grammar.EdgeTypePhraseFiller"

_EdgeTypePhraseFiller_typeNameWithFiller = Core.Name "typeNameWithFiller"

_EdgeTypePhraseFiller_fillerOnly = Core.Name "fillerOnly"

-- | A GQL edge type property types, equivalent to a property types specification
type EdgeTypePropertyTypes = PropertyTypesSpecification

_EdgeTypePropertyTypes = Core.Name "openGql.grammar.EdgeTypePropertyTypes"

-- | A GQL edge type specification: one of several alternative forms
data EdgeTypeSpecification =
  EdgeTypeSpecificationPattern EdgeTypePattern |
  EdgeTypeSpecificationPhrase EdgeTypePhrase
  deriving (Eq, Ord, Read, Show)

_EdgeTypeSpecification = Core.Name "openGql.grammar.EdgeTypeSpecification"

_EdgeTypeSpecification_pattern = Core.Name "pattern"

_EdgeTypeSpecification_phrase = Core.Name "phrase"

-- | A GQL edges synonym: one of a fixed set of alternatives
data EdgesSynonym =
  EdgesSynonymEdges |
  EdgesSynonymRelationships
  deriving (Eq, Ord, Read, Show)

_EdgesSynonym = Core.Name "openGql.grammar.EdgesSynonym"

_EdgesSynonym_edges = Core.Name "edges"

_EdgesSynonym_relationships = Core.Name "relationships"

-- | A GQL element bindings or elements: one of several alternative forms
data ElementBindingsOrElements =
  ElementBindingsOrElementsElementBindings Bool |
  ElementBindingsOrElementsElements
  deriving (Eq, Ord, Read, Show)

_ElementBindingsOrElements = Core.Name "openGql.grammar.ElementBindingsOrElements"

_ElementBindingsOrElements_elementBindings = Core.Name "elementBindings"

_ElementBindingsOrElements_elements = Core.Name "elements"

-- | A GQL element id function, equivalent to a element variable reference
type ElementIdFunction = ElementVariableReference

_ElementIdFunction = Core.Name "openGql.grammar.ElementIdFunction"

-- | A GQL element pattern: one of several alternative forms
data ElementPattern =
  ElementPatternNode NodePattern |
  ElementPatternEdge EdgePattern
  deriving (Eq, Ord, Read, Show)

_ElementPattern = Core.Name "openGql.grammar.ElementPattern"

_ElementPattern_node = Core.Name "node"

_ElementPattern_edge = Core.Name "edge"

-- | A GQL element pattern filler
data ElementPatternFiller =
  ElementPatternFiller {
    elementPatternFillerVariableDeclaration :: (Maybe ElementVariableDeclaration),
    elementPatternFillerIsLabelExpression :: (Maybe IsLabelExpression),
    elementPatternFillerPredicate :: (Maybe ElementPatternPredicate)}
  deriving (Eq, Ord, Read, Show)

_ElementPatternFiller = Core.Name "openGql.grammar.ElementPatternFiller"

_ElementPatternFiller_variableDeclaration = Core.Name "variableDeclaration"

_ElementPatternFiller_isLabelExpression = Core.Name "isLabelExpression"

_ElementPatternFiller_predicate = Core.Name "predicate"

-- | A GQL element pattern predicate: one of several alternative forms
data ElementPatternPredicate =
  ElementPatternPredicateWhereClause ElementPatternWhereClause |
  ElementPatternPredicatePropertySpecification ElementPropertySpecification
  deriving (Eq, Ord, Read, Show)

_ElementPatternPredicate = Core.Name "openGql.grammar.ElementPatternPredicate"

_ElementPatternPredicate_whereClause = Core.Name "whereClause"

_ElementPatternPredicate_propertySpecification = Core.Name "propertySpecification"

-- | A GQL element pattern where clause, equivalent to a search condition
type ElementPatternWhereClause = SearchCondition

_ElementPatternWhereClause = Core.Name "openGql.grammar.ElementPatternWhereClause"

-- | A GQL element property specification, equivalent to a property key value pair list
type ElementPropertySpecification = PropertyKeyValuePairList

_ElementPropertySpecification = Core.Name "openGql.grammar.ElementPropertySpecification"

-- | A list of GQL element type list elements
type ElementTypeList = [ElementTypeSpecification]

_ElementTypeList = Core.Name "openGql.grammar.ElementTypeList"

-- | A GQL element type specification: one of several alternative forms
data ElementTypeSpecification =
  ElementTypeSpecificationNodeType NodeTypeSpecification |
  ElementTypeSpecificationEdgeType EdgeTypeSpecification
  deriving (Eq, Ord, Read, Show)

_ElementTypeSpecification = Core.Name "openGql.grammar.ElementTypeSpecification"

_ElementTypeSpecification_nodeType = Core.Name "nodeType"

_ElementTypeSpecification_edgeType = Core.Name "edgeType"

-- | A GQL element variable, equivalent to a binding variable
type ElementVariable = BindingVariable

_ElementVariable = Core.Name "openGql.grammar.ElementVariable"

-- | A GQL element variable declaration
data ElementVariableDeclaration =
  ElementVariableDeclaration {
    elementVariableDeclarationTemp :: (Maybe Bool),
    elementVariableDeclarationVariable :: ElementVariable}
  deriving (Eq, Ord, Read, Show)

_ElementVariableDeclaration = Core.Name "openGql.grammar.ElementVariableDeclaration"

_ElementVariableDeclaration_temp = Core.Name "temp"

_ElementVariableDeclaration_variable = Core.Name "variable"

-- | A GQL element variable reference, equivalent to a binding variable reference
type ElementVariableReference = BindingVariableReference

_ElementVariableReference = Core.Name "openGql.grammar.ElementVariableReference"

-- | A GQL elements function, equivalent to a path value expression
type ElementsFunction = PathValueExpression

_ElementsFunction = Core.Name "openGql.grammar.ElementsFunction"

-- | A GQL else clause, equivalent to a result
type ElseClause = Result

_ElseClause = Core.Name "openGql.grammar.ElseClause"

-- | A GQL empty type
type EmptyType = ()

_EmptyType = Core.Name "openGql.grammar.EmptyType"

-- | A GQL end transaction command: one of several alternative forms
data EndTransactionCommand =
  EndTransactionCommandRollback RollbackCommand |
  EndTransactionCommandCommit CommitCommand
  deriving (Eq, Ord, Read, Show)

_EndTransactionCommand = Core.Name "openGql.grammar.EndTransactionCommand"

_EndTransactionCommand_rollback = Core.Name "rollback"

_EndTransactionCommand_commit = Core.Name "commit"

-- | A GQL endpoint pair: one of several alternative forms
data EndpointPair =
  EndpointPairDirectedPair EndpointPairDirected |
  EndpointPairUndirectedPair EndpointPairUndirected
  deriving (Eq, Ord, Read, Show)

_EndpointPair = Core.Name "openGql.grammar.EndpointPair"

_EndpointPair_directedPair = Core.Name "directedPair"

_EndpointPair_undirectedPair = Core.Name "undirectedPair"

-- | A GQL endpoint pair directed: one of several alternative forms
data EndpointPairDirected =
  EndpointPairDirectedPointingRight EndpointPairPointingRight |
  EndpointPairDirectedPointingLeft EndpointPairPointingLeft
  deriving (Eq, Ord, Read, Show)

_EndpointPairDirected = Core.Name "openGql.grammar.EndpointPairDirected"

_EndpointPairDirected_pointingRight = Core.Name "pointingRight"

_EndpointPairDirected_pointingLeft = Core.Name "pointingLeft"

-- | A GQL endpoint pair phrase, equivalent to a endpoint pair
type EndpointPairPhrase = EndpointPair

_EndpointPairPhrase = Core.Name "openGql.grammar.EndpointPairPhrase"

-- | A GQL endpoint pair pointing left
data EndpointPairPointingLeft =
  EndpointPairPointingLeft {
    endpointPairPointingLeftDestinationAlias :: DestinationNodeTypeAlias,
    endpointPairPointingLeftSourceAlias :: SourceNodeTypeAlias}
  deriving (Eq, Ord, Read, Show)

_EndpointPairPointingLeft = Core.Name "openGql.grammar.EndpointPairPointingLeft"

_EndpointPairPointingLeft_destinationAlias = Core.Name "destinationAlias"

_EndpointPairPointingLeft_sourceAlias = Core.Name "sourceAlias"

-- | A GQL endpoint pair pointing right
data EndpointPairPointingRight =
  EndpointPairPointingRight {
    endpointPairPointingRightSourceAlias :: SourceNodeTypeAlias,
    endpointPairPointingRightConnector :: ConnectorPointingRight,
    endpointPairPointingRightDestinationAlias :: DestinationNodeTypeAlias}
  deriving (Eq, Ord, Read, Show)

_EndpointPairPointingRight = Core.Name "openGql.grammar.EndpointPairPointingRight"

_EndpointPairPointingRight_sourceAlias = Core.Name "sourceAlias"

_EndpointPairPointingRight_connector = Core.Name "connector"

_EndpointPairPointingRight_destinationAlias = Core.Name "destinationAlias"

-- | A GQL endpoint pair undirected
data EndpointPairUndirected =
  EndpointPairUndirected {
    endpointPairUndirectedSourceAlias :: SourceNodeTypeAlias,
    endpointPairUndirectedConnector :: ConnectorUndirected,
    endpointPairUndirectedDestinationAlias :: DestinationNodeTypeAlias}
  deriving (Eq, Ord, Read, Show)

_EndpointPairUndirected = Core.Name "openGql.grammar.EndpointPairUndirected"

_EndpointPairUndirected_sourceAlias = Core.Name "sourceAlias"

_EndpointPairUndirected_connector = Core.Name "connector"

_EndpointPairUndirected_destinationAlias = Core.Name "destinationAlias"

-- | A GQL exact numeric literal: one of several alternative forms
data ExactNumericLiteral =
  ExactNumericLiteralScientificWithSuffix String |
  ExactNumericLiteralCommonWithSuffix String |
  ExactNumericLiteralCommonWithoutSuffix String |
  ExactNumericLiteralIntegerWithSuffix String |
  ExactNumericLiteralUnsignedInteger UnsignedInteger
  deriving (Eq, Ord, Read, Show)

_ExactNumericLiteral = Core.Name "openGql.grammar.ExactNumericLiteral"

_ExactNumericLiteral_scientificWithSuffix = Core.Name "scientificWithSuffix"

_ExactNumericLiteral_commonWithSuffix = Core.Name "commonWithSuffix"

_ExactNumericLiteral_commonWithoutSuffix = Core.Name "commonWithoutSuffix"

_ExactNumericLiteral_integerWithSuffix = Core.Name "integerWithSuffix"

_ExactNumericLiteral_unsignedInteger = Core.Name "unsignedInteger"

-- | A GQL exact numeric type: one of several alternative forms
data ExactNumericType =
  ExactNumericTypeBinary BinaryExactNumericType |
  ExactNumericTypeDecimal DecimalExactNumericType
  deriving (Eq, Ord, Read, Show)

_ExactNumericType = Core.Name "openGql.grammar.ExactNumericType"

_ExactNumericType_binary = Core.Name "binary"

_ExactNumericType_decimal = Core.Name "decimal"

-- | A GQL exists predicate: one of several alternative forms
data ExistsPredicate =
  ExistsPredicateGraphPatternBrace GraphPattern |
  ExistsPredicateGraphPatternParen GraphPattern |
  ExistsPredicateMatchBlockBrace MatchStatementBlock |
  ExistsPredicateMatchBlockParen MatchStatementBlock |
  ExistsPredicateNestedQuery NestedQuerySpecification
  deriving (Eq, Ord, Read, Show)

_ExistsPredicate = Core.Name "openGql.grammar.ExistsPredicate"

_ExistsPredicate_graphPatternBrace = Core.Name "graphPatternBrace"

_ExistsPredicate_graphPatternParen = Core.Name "graphPatternParen"

_ExistsPredicate_matchBlockBrace = Core.Name "matchBlockBrace"

_ExistsPredicate_matchBlockParen = Core.Name "matchBlockParen"

_ExistsPredicate_nestedQuery = Core.Name "nestedQuery"

-- | A GQL exponential function, equivalent to a numeric value expression
type ExponentialFunction = NumericValueExpression

_ExponentialFunction = Core.Name "openGql.grammar.ExponentialFunction"

-- | A GQL field
data Field =
  Field {
    fieldName :: FieldName,
    fieldValue :: ValueExpression}
  deriving (Eq, Ord, Read, Show)

_Field = Core.Name "openGql.grammar.Field"

_Field_name = Core.Name "name"

_Field_value = Core.Name "value"

-- | A list of GQL field list elements
type FieldList = [Field]

_FieldList = Core.Name "openGql.grammar.FieldList"

-- | A GQL field name
type FieldName = String

_FieldName = Core.Name "openGql.grammar.FieldName"

-- | A GQL field type
data FieldType =
  FieldType {
    fieldTypeFieldName :: FieldName,
    fieldTypeTyped :: (Maybe Typed),
    fieldTypeValueType :: ValueType}
  deriving (Eq, Ord, Read, Show)

_FieldType = Core.Name "openGql.grammar.FieldType"

_FieldType_fieldName = Core.Name "fieldName"

_FieldType_typed = Core.Name "typed"

_FieldType_valueType = Core.Name "valueType"

-- | A list of GQL field type list elements
type FieldTypeList = [FieldType]

_FieldTypeList = Core.Name "openGql.grammar.FieldTypeList"

-- | An optional GQL field types specification
type FieldTypesSpecification = (Maybe FieldTypeList)

_FieldTypesSpecification = Core.Name "openGql.grammar.FieldTypesSpecification"

-- | An optional GQL fields specification
type FieldsSpecification = (Maybe FieldList)

_FieldsSpecification = Core.Name "openGql.grammar.FieldsSpecification"

-- | A GQL filter statement: one of several alternative forms
data FilterStatement =
  FilterStatementWhereClause WhereClause |
  FilterStatementSearchCondition SearchCondition
  deriving (Eq, Ord, Read, Show)

_FilterStatement = Core.Name "openGql.grammar.FilterStatement"

_FilterStatement_whereClause = Core.Name "whereClause"

_FilterStatement_searchCondition = Core.Name "searchCondition"

-- | A GQL fixed length, equivalent to a unsigned integer
type FixedLength = UnsignedInteger

_FixedLength = Core.Name "openGql.grammar.FixedLength"

-- | A GQL fixed quantifier, equivalent to a unsigned integer
type FixedQuantifier = UnsignedInteger

_FixedQuantifier = Core.Name "openGql.grammar.FixedQuantifier"

-- | A GQL float128 type
data Float128Type =
  Float128Type {
    float128TypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_Float128Type = Core.Name "openGql.grammar.Float128Type"

_Float128Type_notNull = Core.Name "notNull"

-- | A GQL float16 type
data Float16Type =
  Float16Type {
    float16TypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_Float16Type = Core.Name "openGql.grammar.Float16Type"

_Float16Type_notNull = Core.Name "notNull"

-- | A GQL float256 type
data Float256Type =
  Float256Type {
    float256TypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_Float256Type = Core.Name "openGql.grammar.Float256Type"

_Float256Type_notNull = Core.Name "notNull"

-- | A GQL float32 type
data Float32Type =
  Float32Type {
    float32TypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_Float32Type = Core.Name "openGql.grammar.Float32Type"

_Float32Type_notNull = Core.Name "notNull"

-- | A GQL float64 type
data Float64Type =
  Float64Type {
    float64TypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_Float64Type = Core.Name "openGql.grammar.Float64Type"

_Float64Type_notNull = Core.Name "notNull"

-- | A GQL float type with precision
data FloatTypeWithPrecision =
  FloatTypeWithPrecision {
    floatTypeWithPrecisionPrecisionAndScale :: (Maybe PrecisionAndScale),
    floatTypeWithPrecisionNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_FloatTypeWithPrecision = Core.Name "openGql.grammar.FloatTypeWithPrecision"

_FloatTypeWithPrecision_precisionAndScale = Core.Name "precisionAndScale"

_FloatTypeWithPrecision_notNull = Core.Name "notNull"

-- | A GQL floor function, equivalent to a numeric value expression
type FloorFunction = NumericValueExpression

_FloorFunction = Core.Name "openGql.grammar.FloorFunction"

-- | A GQL focused linear data modifying statement: one of several alternative forms
data FocusedLinearDataModifyingStatement =
  FocusedLinearDataModifyingStatementSimple FocusedLinearDataModifyingStatementBody |
  FocusedLinearDataModifyingStatementNested FocusedNestedDataModifyingProcedureSpecification
  deriving (Eq, Ord, Read, Show)

_FocusedLinearDataModifyingStatement = Core.Name "openGql.grammar.FocusedLinearDataModifyingStatement"

_FocusedLinearDataModifyingStatement_simple = Core.Name "simple"

_FocusedLinearDataModifyingStatement_nested = Core.Name "nested"

-- | A GQL focused linear data modifying statement body
data FocusedLinearDataModifyingStatementBody =
  FocusedLinearDataModifyingStatementBody {
    focusedLinearDataModifyingStatementBodyUseGraph :: UseGraphClause,
    focusedLinearDataModifyingStatementBodySimpleAccess :: SimpleLinearDataAccessingStatement,
    focusedLinearDataModifyingStatementBodyPrimitiveResult :: (Maybe PrimitiveResultStatement)}
  deriving (Eq, Ord, Read, Show)

_FocusedLinearDataModifyingStatementBody = Core.Name "openGql.grammar.FocusedLinearDataModifyingStatementBody"

_FocusedLinearDataModifyingStatementBody_useGraph = Core.Name "useGraph"

_FocusedLinearDataModifyingStatementBody_simpleAccess = Core.Name "simpleAccess"

_FocusedLinearDataModifyingStatementBody_primitiveResult = Core.Name "primitiveResult"

-- | A GQL focused linear query and primitive result statement part
data FocusedLinearQueryAndPrimitiveResultStatementPart =
  FocusedLinearQueryAndPrimitiveResultStatementPart {
    focusedLinearQueryAndPrimitiveResultStatementPartUseGraph :: UseGraphClause,
    focusedLinearQueryAndPrimitiveResultStatementPartSimple :: SimpleLinearQueryStatement,
    focusedLinearQueryAndPrimitiveResultStatementPartPrimitiveResult :: PrimitiveResultStatement}
  deriving (Eq, Ord, Read, Show)

_FocusedLinearQueryAndPrimitiveResultStatementPart =
    Core.Name "openGql.grammar.FocusedLinearQueryAndPrimitiveResultStatementPart"

_FocusedLinearQueryAndPrimitiveResultStatementPart_useGraph = Core.Name "useGraph"

_FocusedLinearQueryAndPrimitiveResultStatementPart_simple = Core.Name "simple"

_FocusedLinearQueryAndPrimitiveResultStatementPart_primitiveResult = Core.Name "primitiveResult"

-- | A GQL focused linear query statement: one of several alternative forms
data FocusedLinearQueryStatement =
  FocusedLinearQueryStatementParts FocusedLinearQueryStatementPartsAndResult |
  FocusedLinearQueryStatementPrimitive FocusedPrimitiveResultStatement |
  FocusedLinearQueryStatementNested FocusedNestedQuerySpecification |
  FocusedLinearQueryStatementSelect SelectStatement
  deriving (Eq, Ord, Read, Show)

_FocusedLinearQueryStatement = Core.Name "openGql.grammar.FocusedLinearQueryStatement"

_FocusedLinearQueryStatement_parts = Core.Name "parts"

_FocusedLinearQueryStatement_primitive = Core.Name "primitive"

_FocusedLinearQueryStatement_nested = Core.Name "nested"

_FocusedLinearQueryStatement_select = Core.Name "select"

-- | A GQL focused linear query statement part
data FocusedLinearQueryStatementPart =
  FocusedLinearQueryStatementPart {
    focusedLinearQueryStatementPartUseGraph :: UseGraphClause,
    focusedLinearQueryStatementPartSimple :: SimpleLinearQueryStatement}
  deriving (Eq, Ord, Read, Show)

_FocusedLinearQueryStatementPart = Core.Name "openGql.grammar.FocusedLinearQueryStatementPart"

_FocusedLinearQueryStatementPart_useGraph = Core.Name "useGraph"

_FocusedLinearQueryStatementPart_simple = Core.Name "simple"

-- | A GQL focused linear query statement parts and result
data FocusedLinearQueryStatementPartsAndResult =
  FocusedLinearQueryStatementPartsAndResult {
    focusedLinearQueryStatementPartsAndResultParts :: [FocusedLinearQueryStatementPart],
    focusedLinearQueryStatementPartsAndResultResult :: FocusedLinearQueryAndPrimitiveResultStatementPart}
  deriving (Eq, Ord, Read, Show)

_FocusedLinearQueryStatementPartsAndResult = Core.Name "openGql.grammar.FocusedLinearQueryStatementPartsAndResult"

_FocusedLinearQueryStatementPartsAndResult_parts = Core.Name "parts"

_FocusedLinearQueryStatementPartsAndResult_result = Core.Name "result"

-- | A GQL focused nested data modifying procedure specification
data FocusedNestedDataModifyingProcedureSpecification =
  FocusedNestedDataModifyingProcedureSpecification {
    focusedNestedDataModifyingProcedureSpecificationUseGraph :: UseGraphClause,
    focusedNestedDataModifyingProcedureSpecificationNestedSpec :: NestedDataModifyingProcedureSpecification}
  deriving (Eq, Ord, Read, Show)

_FocusedNestedDataModifyingProcedureSpecification =
    Core.Name "openGql.grammar.FocusedNestedDataModifyingProcedureSpecification"

_FocusedNestedDataModifyingProcedureSpecification_useGraph = Core.Name "useGraph"

_FocusedNestedDataModifyingProcedureSpecification_nestedSpec = Core.Name "nestedSpec"

-- | A GQL focused nested query specification
data FocusedNestedQuerySpecification =
  FocusedNestedQuerySpecification {
    focusedNestedQuerySpecificationUseGraph :: UseGraphClause,
    focusedNestedQuerySpecificationNested :: NestedQuerySpecification}
  deriving (Eq, Ord, Read, Show)

_FocusedNestedQuerySpecification = Core.Name "openGql.grammar.FocusedNestedQuerySpecification"

_FocusedNestedQuerySpecification_useGraph = Core.Name "useGraph"

_FocusedNestedQuerySpecification_nested = Core.Name "nested"

-- | A GQL focused primitive result statement
data FocusedPrimitiveResultStatement =
  FocusedPrimitiveResultStatement {
    focusedPrimitiveResultStatementUseGraph :: UseGraphClause,
    focusedPrimitiveResultStatementPrimitiveResult :: PrimitiveResultStatement}
  deriving (Eq, Ord, Read, Show)

_FocusedPrimitiveResultStatement = Core.Name "openGql.grammar.FocusedPrimitiveResultStatement"

_FocusedPrimitiveResultStatement_useGraph = Core.Name "useGraph"

_FocusedPrimitiveResultStatement_primitiveResult = Core.Name "primitiveResult"

-- | A GQL fold character string
data FoldCharacterString =
  FoldCharacterString {
    foldCharacterStringCase :: Case,
    foldCharacterStringValueExpression :: ValueExpression}
  deriving (Eq, Ord, Read, Show)

_FoldCharacterString = Core.Name "openGql.grammar.FoldCharacterString"

_FoldCharacterString_case = Core.Name "case"

_FoldCharacterString_valueExpression = Core.Name "valueExpression"

-- | A GQL for item
data ForItem =
  ForItem {
    forItemAlias :: ForItemAlias,
    forItemSource :: ForItemSource}
  deriving (Eq, Ord, Read, Show)

_ForItem = Core.Name "openGql.grammar.ForItem"

_ForItem_alias = Core.Name "alias"

_ForItem_source = Core.Name "source"

-- | A GQL for item alias, equivalent to a binding variable
type ForItemAlias = BindingVariable

_ForItemAlias = Core.Name "openGql.grammar.ForItemAlias"

-- | A GQL for item source, equivalent to a value expression
type ForItemSource = ValueExpression

_ForItemSource = Core.Name "openGql.grammar.ForItemSource"

-- | A GQL for ordinality or offset
data ForOrdinalityOrOffset =
  ForOrdinalityOrOffset {
    forOrdinalityOrOffsetType :: OrdinalityOrOffsetType,
    forOrdinalityOrOffsetVariable :: BindingVariable}
  deriving (Eq, Ord, Read, Show)

_ForOrdinalityOrOffset = Core.Name "openGql.grammar.ForOrdinalityOrOffset"

_ForOrdinalityOrOffset_type = Core.Name "type"

_ForOrdinalityOrOffset_variable = Core.Name "variable"

-- | A GQL for statement
data ForStatement =
  ForStatement {
    forStatementItem :: ForItem,
    forStatementOrdinalityOrOffset :: (Maybe ForOrdinalityOrOffset)}
  deriving (Eq, Ord, Read, Show)

_ForStatement = Core.Name "openGql.grammar.ForStatement"

_ForStatement_item = Core.Name "item"

_ForStatement_ordinalityOrOffset = Core.Name "ordinalityOrOffset"

-- | A GQL full edge any direction, equivalent to a element pattern filler
type FullEdgeAnyDirection = ElementPatternFiller

_FullEdgeAnyDirection = Core.Name "openGql.grammar.FullEdgeAnyDirection"

-- | A GQL full edge left or right, equivalent to a element pattern filler
type FullEdgeLeftOrRight = ElementPatternFiller

_FullEdgeLeftOrRight = Core.Name "openGql.grammar.FullEdgeLeftOrRight"

-- | A GQL full edge left or undirected, equivalent to a element pattern filler
type FullEdgeLeftOrUndirected = ElementPatternFiller

_FullEdgeLeftOrUndirected = Core.Name "openGql.grammar.FullEdgeLeftOrUndirected"

-- | A GQL full edge pattern: one of several alternative forms
data FullEdgePattern =
  FullEdgePatternPointingLeft FullEdgePointingLeft |
  FullEdgePatternUndirected FullEdgeUndirected |
  FullEdgePatternPointingRight FullEdgePointingRight |
  FullEdgePatternLeftOrUndirected FullEdgeLeftOrUndirected |
  FullEdgePatternUndirectedOrRight FullEdgeUndirectedOrRight |
  FullEdgePatternLeftOrRight FullEdgeLeftOrRight |
  FullEdgePatternAnyDirection FullEdgeAnyDirection
  deriving (Eq, Ord, Read, Show)

_FullEdgePattern = Core.Name "openGql.grammar.FullEdgePattern"

_FullEdgePattern_pointingLeft = Core.Name "pointingLeft"

_FullEdgePattern_undirected = Core.Name "undirected"

_FullEdgePattern_pointingRight = Core.Name "pointingRight"

_FullEdgePattern_leftOrUndirected = Core.Name "leftOrUndirected"

_FullEdgePattern_undirectedOrRight = Core.Name "undirectedOrRight"

_FullEdgePattern_leftOrRight = Core.Name "leftOrRight"

_FullEdgePattern_anyDirection = Core.Name "anyDirection"

-- | A GQL full edge pointing left, equivalent to a element pattern filler
type FullEdgePointingLeft = ElementPatternFiller

_FullEdgePointingLeft = Core.Name "openGql.grammar.FullEdgePointingLeft"

-- | A GQL full edge pointing right, equivalent to a element pattern filler
type FullEdgePointingRight = ElementPatternFiller

_FullEdgePointingRight = Core.Name "openGql.grammar.FullEdgePointingRight"

-- | A GQL full edge undirected, equivalent to a element pattern filler
type FullEdgeUndirected = ElementPatternFiller

_FullEdgeUndirected = Core.Name "openGql.grammar.FullEdgeUndirected"

-- | A GQL full edge undirected or right, equivalent to a element pattern filler
type FullEdgeUndirectedOrRight = ElementPatternFiller

_FullEdgeUndirectedOrRight = Core.Name "openGql.grammar.FullEdgeUndirectedOrRight"

-- | A GQL general literal: one of several alternative forms
data GeneralLiteral =
  GeneralLiteralBoolean BooleanLiteral |
  GeneralLiteralCharacterString CharacterStringLiteral |
  GeneralLiteralByteString ByteStringLiteral |
  GeneralLiteralTemporal TemporalLiteral |
  GeneralLiteralDuration DurationLiteral |
  GeneralLiteralNullLiteral NullLiteral |
  GeneralLiteralList ListLiteral |
  GeneralLiteralRecord RecordLiteral
  deriving (Eq, Ord, Read, Show)

_GeneralLiteral = Core.Name "openGql.grammar.GeneralLiteral"

_GeneralLiteral_boolean = Core.Name "boolean"

_GeneralLiteral_characterString = Core.Name "characterString"

_GeneralLiteral_byteString = Core.Name "byteString"

_GeneralLiteral_temporal = Core.Name "temporal"

_GeneralLiteral_duration = Core.Name "duration"

_GeneralLiteral_nullLiteral = Core.Name "nullLiteral"

_GeneralLiteral_list = Core.Name "list"

_GeneralLiteral_record = Core.Name "record"

-- | A GQL general logarithm argument, equivalent to a numeric value expression
type GeneralLogarithmArgument = NumericValueExpression

_GeneralLogarithmArgument = Core.Name "openGql.grammar.GeneralLogarithmArgument"

-- | A GQL general logarithm base, equivalent to a numeric value expression
type GeneralLogarithmBase = NumericValueExpression

_GeneralLogarithmBase = Core.Name "openGql.grammar.GeneralLogarithmBase"

-- | A GQL general logarithm function
data GeneralLogarithmFunction =
  GeneralLogarithmFunction {
    generalLogarithmFunctionBase :: GeneralLogarithmBase,
    generalLogarithmFunctionArgument :: GeneralLogarithmArgument}
  deriving (Eq, Ord, Read, Show)

_GeneralLogarithmFunction = Core.Name "openGql.grammar.GeneralLogarithmFunction"

_GeneralLogarithmFunction_base = Core.Name "base"

_GeneralLogarithmFunction_argument = Core.Name "argument"

-- | A GQL general quantifier
data GeneralQuantifier =
  GeneralQuantifier {
    generalQuantifierLowerBound :: (Maybe LowerBound),
    generalQuantifierUpperBound :: (Maybe UpperBound)}
  deriving (Eq, Ord, Read, Show)

_GeneralQuantifier = Core.Name "openGql.grammar.GeneralQuantifier"

_GeneralQuantifier_lowerBound = Core.Name "lowerBound"

_GeneralQuantifier_upperBound = Core.Name "upperBound"

-- | A GQL general set function
data GeneralSetFunction =
  GeneralSetFunction {
    generalSetFunctionFunctionType :: GeneralSetFunctionType,
    generalSetFunctionSetQuantifier :: (Maybe SetQuantifier),
    generalSetFunctionValueExpression :: ValueExpression}
  deriving (Eq, Ord, Read, Show)

_GeneralSetFunction = Core.Name "openGql.grammar.GeneralSetFunction"

_GeneralSetFunction_functionType = Core.Name "functionType"

_GeneralSetFunction_setQuantifier = Core.Name "setQuantifier"

_GeneralSetFunction_valueExpression = Core.Name "valueExpression"

-- | A GQL general set function type: one of a fixed set of alternatives
data GeneralSetFunctionType =
  GeneralSetFunctionTypeAvg |
  GeneralSetFunctionTypeCount |
  GeneralSetFunctionTypeMax |
  GeneralSetFunctionTypeMin |
  GeneralSetFunctionTypeSum |
  GeneralSetFunctionTypeCollectList |
  GeneralSetFunctionTypeStddevSamp |
  GeneralSetFunctionTypeStddevPop
  deriving (Eq, Ord, Read, Show)

_GeneralSetFunctionType = Core.Name "openGql.grammar.GeneralSetFunctionType"

_GeneralSetFunctionType_avg = Core.Name "avg"

_GeneralSetFunctionType_count = Core.Name "count"

_GeneralSetFunctionType_max = Core.Name "max"

_GeneralSetFunctionType_min = Core.Name "min"

_GeneralSetFunctionType_sum = Core.Name "sum"

_GeneralSetFunctionType_collectList = Core.Name "collectList"

_GeneralSetFunctionType_stddevSamp = Core.Name "stddevSamp"

_GeneralSetFunctionType_stddevPop = Core.Name "stddevPop"

-- | A GQL general value specification: one of several alternative forms
data GeneralValueSpecification =
  GeneralValueSpecificationDynamicParameterSpecification DynamicParameterSpecification |
  GeneralValueSpecificationSessionUser
  deriving (Eq, Ord, Read, Show)

_GeneralValueSpecification = Core.Name "openGql.grammar.GeneralValueSpecification"

_GeneralValueSpecification_dynamicParameterSpecification = Core.Name "dynamicParameterSpecification"

_GeneralValueSpecification_sessionUser = Core.Name "sessionUser"

-- | A GQL gql program
data GqlProgram =
  GqlProgram {
    gqlProgramActivity :: (Maybe ProgramActivity),
    gqlProgramClose :: (Maybe SessionCloseCommand)}
  deriving (Eq, Ord, Read, Show)

_GqlProgram = Core.Name "openGql.grammar.GqlProgram"

_GqlProgram_activity = Core.Name "activity"

_GqlProgram_close = Core.Name "close"

-- | A GQL graph and nested query specification
data GraphAndNestedQuerySpecification =
  GraphAndNestedQuerySpecification {
    graphAndNestedQuerySpecificationGraphExpression :: GraphExpression,
    graphAndNestedQuerySpecificationNested :: NestedQuerySpecification}
  deriving (Eq, Ord, Read, Show)

_GraphAndNestedQuerySpecification = Core.Name "openGql.grammar.GraphAndNestedQuerySpecification"

_GraphAndNestedQuerySpecification_graphExpression = Core.Name "graphExpression"

_GraphAndNestedQuerySpecification_nested = Core.Name "nested"

-- | A GQL graph expression: one of several alternative forms
data GraphExpression =
  GraphExpressionObject ObjectExpressionPrimary |
  GraphExpressionReference GraphReference |
  GraphExpressionName ObjectNameOrBindingVariable |
  GraphExpressionCurrent CurrentGraph
  deriving (Eq, Ord, Read, Show)

_GraphExpression = Core.Name "openGql.grammar.GraphExpression"

_GraphExpression_object = Core.Name "object"

_GraphExpression_reference = Core.Name "reference"

_GraphExpression_name = Core.Name "name"

_GraphExpression_current = Core.Name "current"

-- | A GQL graph initializer
type GraphInitializer = ()

_GraphInitializer = Core.Name "openGql.grammar.GraphInitializer"

-- | A GQL graph name
type GraphName = String

_GraphName = Core.Name "openGql.grammar.GraphName"

-- | A GQL graph pattern
data GraphPattern =
  GraphPattern {
    graphPatternMatchMode :: (Maybe MatchMode),
    graphPatternPathPatterns :: PathPatternList,
    graphPatternKeepClause :: (Maybe KeepClause),
    graphPatternWhereClause :: (Maybe GraphPatternWhereClause)}
  deriving (Eq, Ord, Read, Show)

_GraphPattern = Core.Name "openGql.grammar.GraphPattern"

_GraphPattern_matchMode = Core.Name "matchMode"

_GraphPattern_pathPatterns = Core.Name "pathPatterns"

_GraphPattern_keepClause = Core.Name "keepClause"

_GraphPattern_whereClause = Core.Name "whereClause"

-- | A GQL graph pattern binding table
data GraphPatternBindingTable =
  GraphPatternBindingTable {
    graphPatternBindingTablePattern :: GraphPattern,
    graphPatternBindingTableYieldClause :: (Maybe GraphPatternYieldClause)}
  deriving (Eq, Ord, Read, Show)

_GraphPatternBindingTable = Core.Name "openGql.grammar.GraphPatternBindingTable"

_GraphPatternBindingTable_pattern = Core.Name "pattern"

_GraphPatternBindingTable_yieldClause = Core.Name "yieldClause"

-- | A GQL graph pattern quantifier: one of several alternative forms
data GraphPatternQuantifier =
  GraphPatternQuantifierAsterisk |
  GraphPatternQuantifierPlusSign |
  GraphPatternQuantifierFixed FixedQuantifier |
  GraphPatternQuantifierGeneral GeneralQuantifier
  deriving (Eq, Ord, Read, Show)

_GraphPatternQuantifier = Core.Name "openGql.grammar.GraphPatternQuantifier"

_GraphPatternQuantifier_asterisk = Core.Name "asterisk"

_GraphPatternQuantifier_plusSign = Core.Name "plusSign"

_GraphPatternQuantifier_fixed = Core.Name "fixed"

_GraphPatternQuantifier_general = Core.Name "general"

-- | A GQL graph pattern where clause, equivalent to a search condition
type GraphPatternWhereClause = SearchCondition

_GraphPatternWhereClause = Core.Name "openGql.grammar.GraphPatternWhereClause"

-- | A GQL graph pattern yield clause, equivalent to a graph pattern yield item list
type GraphPatternYieldClause = GraphPatternYieldItemList

_GraphPatternYieldClause = Core.Name "openGql.grammar.GraphPatternYieldClause"

-- | A GQL graph pattern yield item, equivalent to a binding variable reference
type GraphPatternYieldItem = BindingVariableReference

_GraphPatternYieldItem = Core.Name "openGql.grammar.GraphPatternYieldItem"

-- | A GQL graph pattern yield item list: one of several alternative forms
data GraphPatternYieldItemList =
  GraphPatternYieldItemListItems [GraphPatternYieldItem] |
  GraphPatternYieldItemListNoBindings
  deriving (Eq, Ord, Read, Show)

_GraphPatternYieldItemList = Core.Name "openGql.grammar.GraphPatternYieldItemList"

_GraphPatternYieldItemList_items = Core.Name "items"

_GraphPatternYieldItemList_noBindings = Core.Name "noBindings"

-- | A GQL graph reference: one of several alternative forms
data GraphReference =
  GraphReferenceParentAndGraphName ParentAndGraphName |
  GraphReferenceDelimitedGraphName DelimitedGraphName |
  GraphReferenceHomeGraph HomeGraph |
  GraphReferenceParameterSpecification ReferenceParameterSpecification
  deriving (Eq, Ord, Read, Show)

_GraphReference = Core.Name "openGql.grammar.GraphReference"

_GraphReference_parentAndGraphName = Core.Name "parentAndGraphName"

_GraphReference_delimitedGraphName = Core.Name "delimitedGraphName"

_GraphReference_homeGraph = Core.Name "homeGraph"

_GraphReference_parameterSpecification = Core.Name "parameterSpecification"

-- | A GQL graph reference value type: one of several alternative forms
data GraphReferenceValueType =
  GraphReferenceValueTypeOpen OpenGraphReferenceValueType |
  GraphReferenceValueTypeClosed ClosedGraphReferenceValueType
  deriving (Eq, Ord, Read, Show)

_GraphReferenceValueType = Core.Name "openGql.grammar.GraphReferenceValueType"

_GraphReferenceValueType_open = Core.Name "open"

_GraphReferenceValueType_closed = Core.Name "closed"

-- | A GQL graph source, equivalent to a graph expression
type GraphSource = GraphExpression

_GraphSource = Core.Name "openGql.grammar.GraphSource"

-- | A GQL graph type like graph, equivalent to a graph expression
type GraphTypeLikeGraph = GraphExpression

_GraphTypeLikeGraph = Core.Name "openGql.grammar.GraphTypeLikeGraph"

-- | A GQL graph type name
type GraphTypeName = String

_GraphTypeName = Core.Name "openGql.grammar.GraphTypeName"

-- | A GQL graph type option: one of several alternative forms
data GraphTypeOption =
  GraphTypeOptionOpenGraphType OpenGraphType |
  GraphTypeOptionOfGraphType OfGraphType
  deriving (Eq, Ord, Read, Show)

_GraphTypeOption = Core.Name "openGql.grammar.GraphTypeOption"

_GraphTypeOption_openGraphType = Core.Name "openGraphType"

_GraphTypeOption_ofGraphType = Core.Name "ofGraphType"

-- | A GQL graph type reference: one of several alternative forms
data GraphTypeReference =
  GraphTypeReferenceParentAndTypeName CatalogGraphTypeParentAndName |
  GraphTypeReferenceParameterSpecification ReferenceParameterSpecification
  deriving (Eq, Ord, Read, Show)

_GraphTypeReference = Core.Name "openGql.grammar.GraphTypeReference"

_GraphTypeReference_parentAndTypeName = Core.Name "parentAndTypeName"

_GraphTypeReference_parameterSpecification = Core.Name "parameterSpecification"

-- | A GQL graph type source: one of several alternative forms
data GraphTypeSource =
  GraphTypeSourceCopyOf CopyOfGraphType |
  GraphTypeSourceLikeGraph GraphTypeLikeGraph |
  GraphTypeSourceNestedSpecification NestedGraphTypeSpecification
  deriving (Eq, Ord, Read, Show)

_GraphTypeSource = Core.Name "openGql.grammar.GraphTypeSource"

_GraphTypeSource_copyOf = Core.Name "copyOf"

_GraphTypeSource_likeGraph = Core.Name "likeGraph"

_GraphTypeSource_nestedSpecification = Core.Name "nestedSpecification"

-- | A GQL graph type specification body, equivalent to a element type list
type GraphTypeSpecificationBody = ElementTypeList

_GraphTypeSpecificationBody = Core.Name "openGql.grammar.GraphTypeSpecificationBody"

-- | A GQL graph variable definition
data GraphVariableDefinition =
  GraphVariableDefinition {
    graphVariableDefinitionVariable :: BindingVariable,
    graphVariableDefinitionInitializer :: OptTypedGraphInitializer}
  deriving (Eq, Ord, Read, Show)

_GraphVariableDefinition = Core.Name "openGql.grammar.GraphVariableDefinition"

_GraphVariableDefinition_variable = Core.Name "variable"

_GraphVariableDefinition_initializer = Core.Name "initializer"

-- | A GQL group by clause, equivalent to a grouping element list
type GroupByClause = GroupingElementList

_GroupByClause = Core.Name "openGql.grammar.GroupByClause"

-- | A GQL grouping element, equivalent to a binding variable reference
type GroupingElement = BindingVariableReference

_GroupingElement = Core.Name "openGql.grammar.GroupingElement"

-- | A GQL grouping element list: one of several alternative forms
data GroupingElementList =
  GroupingElementListElements [GroupingElement] |
  GroupingElementListEmptySet
  deriving (Eq, Ord, Read, Show)

_GroupingElementList = Core.Name "openGql.grammar.GroupingElementList"

_GroupingElementList_elements = Core.Name "elements"

_GroupingElementList_emptySet = Core.Name "emptySet"

-- | A GQL having clause, equivalent to a search condition
type HavingClause = SearchCondition

_HavingClause = Core.Name "openGql.grammar.HavingClause"

-- | A GQL home graph: one of a fixed set of alternatives
data HomeGraph =
  HomeGraphHomePropertyGraph |
  HomeGraphHomeGraph
  deriving (Eq, Ord, Read, Show)

_HomeGraph = Core.Name "openGql.grammar.HomeGraph"

_HomeGraph_homePropertyGraph = Core.Name "homePropertyGraph"

_HomeGraph_homeGraph = Core.Name "homeGraph"

-- | A GQL identifier
type Identifier = String

_Identifier = Core.Name "openGql.grammar.Identifier"

-- | A GQL immaterial value type: one of several alternative forms
data ImmaterialValueType =
  ImmaterialValueTypeNullType NullType |
  ImmaterialValueTypeEmptyType EmptyType
  deriving (Eq, Ord, Read, Show)

_ImmaterialValueType = Core.Name "openGql.grammar.ImmaterialValueType"

_ImmaterialValueType_nullType = Core.Name "nullType"

_ImmaterialValueType_emptyType = Core.Name "emptyType"

-- | A GQL implies: one of a fixed set of alternatives
data Implies =
  ImpliesRightDoubleArrow |
  ImpliesImplies
  deriving (Eq, Ord, Read, Show)

_Implies = Core.Name "openGql.grammar.Implies"

_Implies_rightDoubleArrow = Core.Name "rightDoubleArrow"

_Implies_implies = Core.Name "implies"

-- | A GQL independent value expression, equivalent to a numeric value expression
type IndependentValueExpression = NumericValueExpression

_IndependentValueExpression = Core.Name "openGql.grammar.IndependentValueExpression"

-- | A GQL inline procedure call
data InlineProcedureCall =
  InlineProcedureCall {
    inlineProcedureCallScope :: (Maybe VariableScopeClause),
    inlineProcedureCallNested :: NestedProcedureSpecification}
  deriving (Eq, Ord, Read, Show)

_InlineProcedureCall = Core.Name "openGql.grammar.InlineProcedureCall"

_InlineProcedureCall_scope = Core.Name "scope"

_InlineProcedureCall_nested = Core.Name "nested"

-- | A GQL insert edge and node
data InsertEdgeAndNode =
  InsertEdgeAndNode {
    insertEdgeAndNodeEdge :: InsertEdgePattern,
    insertEdgeAndNodeNode :: InsertNodePattern}
  deriving (Eq, Ord, Read, Show)

_InsertEdgeAndNode = Core.Name "openGql.grammar.InsertEdgeAndNode"

_InsertEdgeAndNode_edge = Core.Name "edge"

_InsertEdgeAndNode_node = Core.Name "node"

-- | A GQL insert edge pattern: one of several alternative forms
data InsertEdgePattern =
  InsertEdgePatternPointingLeft InsertEdgePointingLeft |
  InsertEdgePatternPointingRight InsertEdgePointingRight |
  InsertEdgePatternUndirected InsertEdgeUndirected
  deriving (Eq, Ord, Read, Show)

_InsertEdgePattern = Core.Name "openGql.grammar.InsertEdgePattern"

_InsertEdgePattern_pointingLeft = Core.Name "pointingLeft"

_InsertEdgePattern_pointingRight = Core.Name "pointingRight"

_InsertEdgePattern_undirected = Core.Name "undirected"

-- | An optional GQL insert edge pointing left
type InsertEdgePointingLeft = (Maybe InsertElementPatternFiller)

_InsertEdgePointingLeft = Core.Name "openGql.grammar.InsertEdgePointingLeft"

-- | An optional GQL insert edge pointing right
type InsertEdgePointingRight = (Maybe InsertElementPatternFiller)

_InsertEdgePointingRight = Core.Name "openGql.grammar.InsertEdgePointingRight"

-- | An optional GQL insert edge undirected
type InsertEdgeUndirected = (Maybe InsertElementPatternFiller)

_InsertEdgeUndirected = Core.Name "openGql.grammar.InsertEdgeUndirected"

-- | A GQL insert element pattern filler
data InsertElementPatternFiller =
  InsertElementPatternFiller {
    insertElementPatternFillerVariableDeclaration :: (Maybe ElementVariableDeclaration),
    insertElementPatternFillerLabelAndProperties :: (Maybe LabelAndPropertySetSpecification)}
  deriving (Eq, Ord, Read, Show)

_InsertElementPatternFiller = Core.Name "openGql.grammar.InsertElementPatternFiller"

_InsertElementPatternFiller_variableDeclaration = Core.Name "variableDeclaration"

_InsertElementPatternFiller_labelAndProperties = Core.Name "labelAndProperties"

-- | A GQL insert graph pattern, equivalent to a insert path pattern list
type InsertGraphPattern = InsertPathPatternList

_InsertGraphPattern = Core.Name "openGql.grammar.InsertGraphPattern"

-- | An optional GQL insert node pattern
type InsertNodePattern = (Maybe InsertElementPatternFiller)

_InsertNodePattern = Core.Name "openGql.grammar.InsertNodePattern"

-- | A GQL insert path pattern
data InsertPathPattern =
  InsertPathPattern {
    insertPathPatternStartNode :: InsertNodePattern,
    insertPathPatternEdgesAndNodes :: [InsertEdgeAndNode]}
  deriving (Eq, Ord, Read, Show)

_InsertPathPattern = Core.Name "openGql.grammar.InsertPathPattern"

_InsertPathPattern_startNode = Core.Name "startNode"

_InsertPathPattern_edgesAndNodes = Core.Name "edgesAndNodes"

-- | A list of GQL insert path pattern list elements
type InsertPathPatternList = [InsertPathPattern]

_InsertPathPatternList = Core.Name "openGql.grammar.InsertPathPatternList"

-- | A GQL insert statement, equivalent to a insert graph pattern
type InsertStatement = InsertGraphPattern

_InsertStatement = Core.Name "openGql.grammar.InsertStatement"

-- | A GQL int128 type
data Int128Type =
  Int128Type {
    int128TypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_Int128Type = Core.Name "openGql.grammar.Int128Type"

_Int128Type_notNull = Core.Name "notNull"

-- | A GQL int16 type
data Int16Type =
  Int16Type {
    int16TypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_Int16Type = Core.Name "openGql.grammar.Int16Type"

_Int16Type_notNull = Core.Name "notNull"

-- | A GQL int256 type
data Int256Type =
  Int256Type {
    int256TypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_Int256Type = Core.Name "openGql.grammar.Int256Type"

_Int256Type_notNull = Core.Name "notNull"

-- | A GQL int32 type
data Int32Type =
  Int32Type {
    int32TypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_Int32Type = Core.Name "openGql.grammar.Int32Type"

_Int32Type_notNull = Core.Name "notNull"

-- | A GQL int64 type
data Int64Type =
  Int64Type {
    int64TypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_Int64Type = Core.Name "openGql.grammar.Int64Type"

_Int64Type_notNull = Core.Name "notNull"

-- | A GQL int8 type
data Int8Type =
  Int8Type {
    int8TypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_Int8Type = Core.Name "openGql.grammar.Int8Type"

_Int8Type_notNull = Core.Name "notNull"

-- | A GQL int with precision
data IntWithPrecision =
  IntWithPrecision {
    intWithPrecisionPrecision :: (Maybe Precision),
    intWithPrecisionNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_IntWithPrecision = Core.Name "openGql.grammar.IntWithPrecision"

_IntWithPrecision_precision = Core.Name "precision"

_IntWithPrecision_notNull = Core.Name "notNull"

-- | A GQL integer128 type
data Integer128Type =
  Integer128Type {
    integer128TypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_Integer128Type = Core.Name "openGql.grammar.Integer128Type"

_Integer128Type_notNull = Core.Name "notNull"

-- | A GQL integer16 type
data Integer16Type =
  Integer16Type {
    integer16TypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_Integer16Type = Core.Name "openGql.grammar.Integer16Type"

_Integer16Type_notNull = Core.Name "notNull"

-- | A GQL integer256 type
data Integer256Type =
  Integer256Type {
    integer256TypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_Integer256Type = Core.Name "openGql.grammar.Integer256Type"

_Integer256Type_notNull = Core.Name "notNull"

-- | A GQL integer32 type
data Integer32Type =
  Integer32Type {
    integer32TypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_Integer32Type = Core.Name "openGql.grammar.Integer32Type"

_Integer32Type_notNull = Core.Name "notNull"

-- | A GQL integer64 type
data Integer64Type =
  Integer64Type {
    integer64TypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_Integer64Type = Core.Name "openGql.grammar.Integer64Type"

_Integer64Type_notNull = Core.Name "notNull"

-- | A GQL integer8 type
data Integer8Type =
  Integer8Type {
    integer8TypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_Integer8Type = Core.Name "openGql.grammar.Integer8Type"

_Integer8Type_notNull = Core.Name "notNull"

-- | A GQL integer with precision
data IntegerWithPrecision =
  IntegerWithPrecision {
    integerWithPrecisionPrecision :: (Maybe Precision),
    integerWithPrecisionNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_IntegerWithPrecision = Core.Name "openGql.grammar.IntegerWithPrecision"

_IntegerWithPrecision_precision = Core.Name "precision"

_IntegerWithPrecision_notNull = Core.Name "notNull"

-- | A GQL is label expression
data IsLabelExpression =
  IsLabelExpression {
    isLabelExpressionIsOrColon :: IsOrColon,
    isLabelExpressionLabel :: LabelExpression}
  deriving (Eq, Ord, Read, Show)

_IsLabelExpression = Core.Name "openGql.grammar.IsLabelExpression"

_IsLabelExpression_isOrColon = Core.Name "isOrColon"

_IsLabelExpression_label = Core.Name "label"

-- | A GQL is labeled or colon: one of several alternative forms
data IsLabeledOrColon =
  IsLabeledOrColonNot Bool |
  IsLabeledOrColonColon
  deriving (Eq, Ord, Read, Show)

_IsLabeledOrColon = Core.Name "openGql.grammar.IsLabeledOrColon"

_IsLabeledOrColon_not = Core.Name "not"

_IsLabeledOrColon_colon = Core.Name "colon"

-- | A GQL is not expression
data IsNotExpr =
  IsNotExpr {
    isNotExprValueExpression :: ValueExpression,
    isNotExprNot :: Bool,
    isNotExprTruthValue :: TruthValue}
  deriving (Eq, Ord, Read, Show)

_IsNotExpr = Core.Name "openGql.grammar.IsNotExpr"

_IsNotExpr_valueExpression = Core.Name "valueExpression"

_IsNotExpr_not = Core.Name "not"

_IsNotExpr_truthValue = Core.Name "truthValue"

-- | A GQL is or colon: one of a fixed set of alternatives
data IsOrColon =
  IsOrColonIs |
  IsOrColonColon
  deriving (Eq, Ord, Read, Show)

_IsOrColon = Core.Name "openGql.grammar.IsOrColon"

_IsOrColon_is = Core.Name "is"

_IsOrColon_colon = Core.Name "colon"

-- | A GQL is or colon with labels
data IsOrColonWithLabels =
  IsOrColonWithLabels {
    isOrColonWithLabelsIsOrColon :: IsOrColon,
    isOrColonWithLabelsLabels :: LabelSetSpecification}
  deriving (Eq, Ord, Read, Show)

_IsOrColonWithLabels = Core.Name "openGql.grammar.IsOrColonWithLabels"

_IsOrColonWithLabels_isOrColon = Core.Name "isOrColon"

_IsOrColonWithLabels_labels = Core.Name "labels"

-- | A GQL keep clause, equivalent to a path pattern prefix
type KeepClause = PathPatternPrefix

_KeepClause = Core.Name "openGql.grammar.KeepClause"

-- | A GQL label and property set specification
data LabelAndPropertySetSpecification =
  LabelAndPropertySetSpecification {
    labelAndPropertySetSpecificationIsOrColon :: (Maybe IsOrColon),
    labelAndPropertySetSpecificationLabelSet :: (Maybe LabelSetSpecification),
    labelAndPropertySetSpecificationPropertySpecification :: (Maybe ElementPropertySpecification)}
  deriving (Eq, Ord, Read, Show)

_LabelAndPropertySetSpecification = Core.Name "openGql.grammar.LabelAndPropertySetSpecification"

_LabelAndPropertySetSpecification_isOrColon = Core.Name "isOrColon"

_LabelAndPropertySetSpecification_labelSet = Core.Name "labelSet"

_LabelAndPropertySetSpecification_propertySpecification = Core.Name "propertySpecification"

-- | A GQL label expression: one of several alternative forms
data LabelExpression =
  LabelExpressionNegation LabelExpression |
  LabelExpressionConjunction ConjunctionLabelExpression |
  LabelExpressionDisjunction DisjunctionLabelExpression |
  LabelExpressionName LabelName |
  LabelExpressionWildcard |
  LabelExpressionParenthesized LabelExpression
  deriving (Eq, Ord, Read, Show)

_LabelExpression = Core.Name "openGql.grammar.LabelExpression"

_LabelExpression_negation = Core.Name "negation"

_LabelExpression_conjunction = Core.Name "conjunction"

_LabelExpression_disjunction = Core.Name "disjunction"

_LabelExpression_name = Core.Name "name"

_LabelExpression_wildcard = Core.Name "wildcard"

_LabelExpression_parenthesized = Core.Name "parenthesized"

-- | A GQL label name
type LabelName = String

_LabelName = Core.Name "openGql.grammar.LabelName"

-- | A GQL label set phrase: one of several alternative forms
data LabelSetPhrase =
  LabelSetPhraseSingleLabel LabelName |
  LabelSetPhraseMultipleLabels LabelSetSpecification |
  LabelSetPhraseIsOrColonWithLabels IsOrColonWithLabels
  deriving (Eq, Ord, Read, Show)

_LabelSetPhrase = Core.Name "openGql.grammar.LabelSetPhrase"

_LabelSetPhrase_singleLabel = Core.Name "singleLabel"

_LabelSetPhrase_multipleLabels = Core.Name "multipleLabels"

_LabelSetPhrase_isOrColonWithLabels = Core.Name "isOrColonWithLabels"

-- | A list of GQL label set specification elements
type LabelSetSpecification = [LabelName]

_LabelSetSpecification = Core.Name "openGql.grammar.LabelSetSpecification"

-- | A GQL labeled predicate
data LabeledPredicate =
  LabeledPredicate {
    labeledPredicateElementVariableReference :: ElementVariableReference,
    labeledPredicateLabeledPart :: LabeledPredicatePart2}
  deriving (Eq, Ord, Read, Show)

_LabeledPredicate = Core.Name "openGql.grammar.LabeledPredicate"

_LabeledPredicate_elementVariableReference = Core.Name "elementVariableReference"

_LabeledPredicate_labeledPart = Core.Name "labeledPart"

-- | A GQL labeled predicate part2
data LabeledPredicatePart2 =
  LabeledPredicatePart2 {
    labeledPredicatePart2IsLabeledOrColon :: IsLabeledOrColon,
    labeledPredicatePart2LabelExpression :: LabelExpression}
  deriving (Eq, Ord, Read, Show)

_LabeledPredicatePart2 = Core.Name "openGql.grammar.LabeledPredicatePart2"

_LabeledPredicatePart2_isLabeledOrColon = Core.Name "isLabeledOrColon"

_LabeledPredicatePart2_labelExpression = Core.Name "labelExpression"

-- | A GQL length expression: one of several alternative forms
data LengthExpression =
  LengthExpressionChar CharLengthExpression |
  LengthExpressionByte ByteLengthExpression |
  LengthExpressionPath PathLengthExpression
  deriving (Eq, Ord, Read, Show)

_LengthExpression = Core.Name "openGql.grammar.LengthExpression"

_LengthExpression_char = Core.Name "char"

_LengthExpression_byte = Core.Name "byte"

_LengthExpression_path = Core.Name "path"

-- | A GQL let statement, equivalent to a let variable definition list
type LetStatement = LetVariableDefinitionList

_LetStatement = Core.Name "openGql.grammar.LetStatement"

-- | A GQL let value expression
data LetValueExpression =
  LetValueExpression {
    letValueExpressionLetVariables :: LetVariableDefinitionList,
    letValueExpressionValueExpression :: ValueExpression}
  deriving (Eq, Ord, Read, Show)

_LetValueExpression = Core.Name "openGql.grammar.LetValueExpression"

_LetValueExpression_letVariables = Core.Name "letVariables"

_LetValueExpression_valueExpression = Core.Name "valueExpression"

-- | A GQL let variable definition: one of several alternative forms
data LetVariableDefinition =
  LetVariableDefinitionValueVariable ValueVariableDefinition |
  LetVariableDefinitionBindingEqualsValue BindingEqualsValue
  deriving (Eq, Ord, Read, Show)

_LetVariableDefinition = Core.Name "openGql.grammar.LetVariableDefinition"

_LetVariableDefinition_valueVariable = Core.Name "valueVariable"

_LetVariableDefinition_bindingEqualsValue = Core.Name "bindingEqualsValue"

-- | A list of GQL let variable definition list elements
type LetVariableDefinitionList = [LetVariableDefinition]

_LetVariableDefinitionList = Core.Name "openGql.grammar.LetVariableDefinitionList"

-- | A GQL limit clause, equivalent to a non negative integer specification
type LimitClause = NonNegativeIntegerSpecification

_LimitClause = Core.Name "openGql.grammar.LimitClause"

-- | A list of GQL linear catalog modifying statement elements
type LinearCatalogModifyingStatement = [SimpleCatalogModifyingStatement]

_LinearCatalogModifyingStatement = Core.Name "openGql.grammar.LinearCatalogModifyingStatement"

-- | A GQL linear data modifying statement: one of several alternative forms
data LinearDataModifyingStatement =
  LinearDataModifyingStatementFocused FocusedLinearDataModifyingStatement |
  LinearDataModifyingStatementAmbient AmbientLinearDataModifyingStatement
  deriving (Eq, Ord, Read, Show)

_LinearDataModifyingStatement = Core.Name "openGql.grammar.LinearDataModifyingStatement"

_LinearDataModifyingStatement_focused = Core.Name "focused"

_LinearDataModifyingStatement_ambient = Core.Name "ambient"

-- | A GQL linear query statement: one of several alternative forms
data LinearQueryStatement =
  LinearQueryStatementFocused FocusedLinearQueryStatement |
  LinearQueryStatementAmbient AmbientLinearQueryStatement
  deriving (Eq, Ord, Read, Show)

_LinearQueryStatement = Core.Name "openGql.grammar.LinearQueryStatement"

_LinearQueryStatement_focused = Core.Name "focused"

_LinearQueryStatement_ambient = Core.Name "ambient"

-- | A GQL list element, equivalent to a value expression
type ListElement = ValueExpression

_ListElement = Core.Name "openGql.grammar.ListElement"

-- | A list of GQL list element list elements
type ListElementList = [ListElement]

_ListElementList = Core.Name "openGql.grammar.ListElementList"

-- | A GQL list literal, equivalent to a list value constructor by enumeration
type ListLiteral = ListValueConstructorByEnumeration

_ListLiteral = Core.Name "openGql.grammar.ListLiteral"

-- | A GQL list value constructor, equivalent to a list value constructor by enumeration
type ListValueConstructor = ListValueConstructorByEnumeration

_ListValueConstructor = Core.Name "openGql.grammar.ListValueConstructor"

-- | A GQL list value constructor by enumeration
data ListValueConstructorByEnumeration =
  ListValueConstructorByEnumeration {
    listValueConstructorByEnumerationListValueTypeName :: (Maybe ListValueTypeName),
    listValueConstructorByEnumerationElements :: (Maybe ListElementList)}
  deriving (Eq, Ord, Read, Show)

_ListValueConstructorByEnumeration = Core.Name "openGql.grammar.ListValueConstructorByEnumeration"

_ListValueConstructorByEnumeration_listValueTypeName = Core.Name "listValueTypeName"

_ListValueConstructorByEnumeration_elements = Core.Name "elements"

-- | A GQL list value expression, equivalent to a value expression
type ListValueExpression = ValueExpression

_ListValueExpression = Core.Name "openGql.grammar.ListValueExpression"

-- | A GQL list value function: one of several alternative forms
data ListValueFunction =
  ListValueFunctionTrim TrimListFunction |
  ListValueFunctionElements ElementsFunction
  deriving (Eq, Ord, Read, Show)

_ListValueFunction = Core.Name "openGql.grammar.ListValueFunction"

_ListValueFunction_trim = Core.Name "trim"

_ListValueFunction_elements = Core.Name "elements"

-- | A GQL list value type alt1
data ListValueTypeAlt1 =
  ListValueTypeAlt1 {
    listValueTypeAlt1TypeName :: ListValueTypeName,
    listValueTypeAlt1ValueType :: ValueType,
    listValueTypeAlt1MaxLength :: (Maybe MaxLength),
    listValueTypeAlt1NotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_ListValueTypeAlt1 = Core.Name "openGql.grammar.ListValueTypeAlt1"

_ListValueTypeAlt1_typeName = Core.Name "typeName"

_ListValueTypeAlt1_valueType = Core.Name "valueType"

_ListValueTypeAlt1_maxLength = Core.Name "maxLength"

_ListValueTypeAlt1_notNull = Core.Name "notNull"

-- | A GQL list value type alt2
data ListValueTypeAlt2 =
  ListValueTypeAlt2 {
    listValueTypeAlt2ValueType :: ValueType,
    listValueTypeAlt2TypeName :: ListValueTypeName,
    listValueTypeAlt2MaxLength :: (Maybe MaxLength),
    listValueTypeAlt2NotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_ListValueTypeAlt2 = Core.Name "openGql.grammar.ListValueTypeAlt2"

_ListValueTypeAlt2_valueType = Core.Name "valueType"

_ListValueTypeAlt2_typeName = Core.Name "typeName"

_ListValueTypeAlt2_maxLength = Core.Name "maxLength"

_ListValueTypeAlt2_notNull = Core.Name "notNull"

-- | A GQL list value type alt3
data ListValueTypeAlt3 =
  ListValueTypeAlt3 {
    listValueTypeAlt3TypeName :: ListValueTypeName,
    listValueTypeAlt3MaxLength :: (Maybe MaxLength),
    listValueTypeAlt3NotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_ListValueTypeAlt3 = Core.Name "openGql.grammar.ListValueTypeAlt3"

_ListValueTypeAlt3_typeName = Core.Name "typeName"

_ListValueTypeAlt3_maxLength = Core.Name "maxLength"

_ListValueTypeAlt3_notNull = Core.Name "notNull"

-- | A GQL list value type name
data ListValueTypeName =
  ListValueTypeName {
    listValueTypeNameGroup :: Bool,
    listValueTypeNameSynonym :: ListValueTypeNameSynonym}
  deriving (Eq, Ord, Read, Show)

_ListValueTypeName = Core.Name "openGql.grammar.ListValueTypeName"

_ListValueTypeName_group = Core.Name "group"

_ListValueTypeName_synonym = Core.Name "synonym"

-- | A GQL list value type name synonym: one of a fixed set of alternatives
data ListValueTypeNameSynonym =
  ListValueTypeNameSynonymList |
  ListValueTypeNameSynonymArray
  deriving (Eq, Ord, Read, Show)

_ListValueTypeNameSynonym = Core.Name "openGql.grammar.ListValueTypeNameSynonym"

_ListValueTypeNameSynonym_list = Core.Name "list"

_ListValueTypeNameSynonym_array = Core.Name "array"

-- | A GQL local datetime type
data LocalDatetimeType =
  LocalDatetimeType {
    localDatetimeTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_LocalDatetimeType = Core.Name "openGql.grammar.LocalDatetimeType"

_LocalDatetimeType_notNull = Core.Name "notNull"

-- | A GQL local datetime type choice: one of several alternative forms
data LocalDatetimeTypeChoice =
  LocalDatetimeTypeChoiceLocalDatetime LocalDatetimeType |
  LocalDatetimeTypeChoiceTimestampWithoutTimeZone TimestampWithoutTimeZoneType
  deriving (Eq, Ord, Read, Show)

_LocalDatetimeTypeChoice = Core.Name "openGql.grammar.LocalDatetimeTypeChoice"

_LocalDatetimeTypeChoice_localDatetime = Core.Name "localDatetime"

_LocalDatetimeTypeChoice_timestampWithoutTimeZone = Core.Name "timestampWithoutTimeZone"

-- | A GQL local node type alias
type LocalNodeTypeAlias = String

_LocalNodeTypeAlias = Core.Name "openGql.grammar.LocalNodeTypeAlias"

-- | A GQL local time type
data LocalTimeType =
  LocalTimeType {
    localTimeTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_LocalTimeType = Core.Name "openGql.grammar.LocalTimeType"

_LocalTimeType_notNull = Core.Name "notNull"

-- | A GQL local time type choice: one of several alternative forms
data LocalTimeTypeChoice =
  LocalTimeTypeChoiceLocalTime LocalTimeType |
  LocalTimeTypeChoiceTimeWithoutTimeZone TimeWithoutTimeZoneType
  deriving (Eq, Ord, Read, Show)

_LocalTimeTypeChoice = Core.Name "openGql.grammar.LocalTimeTypeChoice"

_LocalTimeTypeChoice_localTime = Core.Name "localTime"

_LocalTimeTypeChoice_timeWithoutTimeZone = Core.Name "timeWithoutTimeZone"

-- | A GQL localdatetime function: one of several alternative forms
data LocaldatetimeFunction =
  LocaldatetimeFunctionLocalTimestamp |
  LocaldatetimeFunctionLocalDatetimeWithParams (Maybe DatetimeFunctionParameters)
  deriving (Eq, Ord, Read, Show)

_LocaldatetimeFunction = Core.Name "openGql.grammar.LocaldatetimeFunction"

_LocaldatetimeFunction_localTimestamp = Core.Name "localTimestamp"

_LocaldatetimeFunction_localDatetimeWithParams = Core.Name "localDatetimeWithParams"

-- | An optional GQL localtime function
type LocaltimeFunction = (Maybe TimeFunctionParameters)

_LocaltimeFunction = Core.Name "openGql.grammar.LocaltimeFunction"

-- | A GQL lower bound, equivalent to a unsigned integer
type LowerBound = UnsignedInteger

_LowerBound = Core.Name "openGql.grammar.LowerBound"

-- | A GQL match mode: one of several alternative forms
data MatchMode =
  MatchModeRepeatableElements RepeatableElementsMatchMode |
  MatchModeDifferentEdges DifferentEdgesMatchMode
  deriving (Eq, Ord, Read, Show)

_MatchMode = Core.Name "openGql.grammar.MatchMode"

_MatchMode_repeatableElements = Core.Name "repeatableElements"

_MatchMode_differentEdges = Core.Name "differentEdges"

-- | A GQL match statement: one of several alternative forms
data MatchStatement =
  MatchStatementSimple SimpleMatchStatement |
  MatchStatementOptional OptionalMatchStatement
  deriving (Eq, Ord, Read, Show)

_MatchStatement = Core.Name "openGql.grammar.MatchStatement"

_MatchStatement_simple = Core.Name "simple"

_MatchStatement_optional = Core.Name "optional"

-- | A list of GQL match statement block elements
type MatchStatementBlock = [MatchStatement]

_MatchStatementBlock = Core.Name "openGql.grammar.MatchStatementBlock"

-- | A GQL max length, equivalent to a unsigned integer
type MaxLength = UnsignedInteger

_MaxLength = Core.Name "openGql.grammar.MaxLength"

-- | A GQL min length, equivalent to a unsigned integer
type MinLength = UnsignedInteger

_MinLength = Core.Name "openGql.grammar.MinLength"

-- | A GQL modulus expression
data ModulusExpression =
  ModulusExpression {
    modulusExpressionDividend :: NumericValueExpressionDividend,
    modulusExpressionDivisor :: NumericValueExpressionDivisor}
  deriving (Eq, Ord, Read, Show)

_ModulusExpression = Core.Name "openGql.grammar.ModulusExpression"

_ModulusExpression_dividend = Core.Name "dividend"

_ModulusExpression_divisor = Core.Name "divisor"

-- | A GQL mul div numeric value expression
data MulDivNumericValueExpression =
  MulDivNumericValueExpression {
    mulDivNumericValueExpressionLeft :: NumericValueExpression,
    mulDivNumericValueExpressionOperator :: MultDivOperator,
    mulDivNumericValueExpressionRight :: NumericValueExpression}
  deriving (Eq, Ord, Read, Show)

_MulDivNumericValueExpression = Core.Name "openGql.grammar.MulDivNumericValueExpression"

_MulDivNumericValueExpression_left = Core.Name "left"

_MulDivNumericValueExpression_operator = Core.Name "operator"

_MulDivNumericValueExpression_right = Core.Name "right"

-- | A GQL mult div expression
data MultDivExpr =
  MultDivExpr {
    multDivExprLeft :: ValueExpression,
    multDivExprOperator :: MultDivOperator,
    multDivExprRight :: ValueExpression}
  deriving (Eq, Ord, Read, Show)

_MultDivExpr = Core.Name "openGql.grammar.MultDivExpr"

_MultDivExpr_left = Core.Name "left"

_MultDivExpr_operator = Core.Name "operator"

_MultDivExpr_right = Core.Name "right"

-- | A GQL mult div operator: one of a fixed set of alternatives
data MultDivOperator =
  MultDivOperatorMultiply |
  MultDivOperatorDivide
  deriving (Eq, Ord, Read, Show)

_MultDivOperator = Core.Name "openGql.grammar.MultDivOperator"

_MultDivOperator_multiply = Core.Name "multiply"

_MultDivOperator_divide = Core.Name "divide"

-- | A GQL named procedure call
data NamedProcedureCall =
  NamedProcedureCall {
    namedProcedureCallReference :: ProcedureReference,
    namedProcedureCallArguments :: (Maybe ProcedureArgumentList),
    namedProcedureCallYield :: (Maybe YieldClause)}
  deriving (Eq, Ord, Read, Show)

_NamedProcedureCall = Core.Name "openGql.grammar.NamedProcedureCall"

_NamedProcedureCall_reference = Core.Name "reference"

_NamedProcedureCall_arguments = Core.Name "arguments"

_NamedProcedureCall_yield = Core.Name "yield"

-- | A GQL natural logarithm, equivalent to a numeric value expression
type NaturalLogarithm = NumericValueExpression

_NaturalLogarithm = Core.Name "openGql.grammar.NaturalLogarithm"

-- | A GQL nested binding table query specification
type NestedBindingTableQuerySpecification = ()

_NestedBindingTableQuerySpecification = Core.Name "openGql.grammar.NestedBindingTableQuerySpecification"

-- | A GQL nested data modifying procedure specification, equivalent to a procedure body
type NestedDataModifyingProcedureSpecification = ProcedureBody

_NestedDataModifyingProcedureSpecification = Core.Name "openGql.grammar.NestedDataModifyingProcedureSpecification"

-- | A GQL nested graph type specification, equivalent to a graph type specification body
type NestedGraphTypeSpecification = GraphTypeSpecificationBody

_NestedGraphTypeSpecification = Core.Name "openGql.grammar.NestedGraphTypeSpecification"

-- | A GQL nested procedure specification, equivalent to a procedure specification
type NestedProcedureSpecification = ProcedureSpecification

_NestedProcedureSpecification = Core.Name "openGql.grammar.NestedProcedureSpecification"

-- | A GQL nested query specification, equivalent to a procedure body
type NestedQuerySpecification = ProcedureBody

_NestedQuerySpecification = Core.Name "openGql.grammar.NestedQuerySpecification"

-- | A GQL next statement
data NextStatement =
  NextStatement {
    nextStatementYieldClause :: (Maybe YieldClause),
    nextStatementStatement :: Statement}
  deriving (Eq, Ord, Read, Show)

_NextStatement = Core.Name "openGql.grammar.NextStatement"

_NextStatement_yieldClause = Core.Name "yieldClause"

_NextStatement_statement = Core.Name "statement"

-- | A GQL node key label set with content
data NodeKeyLabelSetWithContent =
  NodeKeyLabelSetWithContent {
    nodeKeyLabelSetWithContentKeyLabelSet :: NodeTypeKeyLabelSet,
    nodeKeyLabelSetWithContentImpliedContent :: (Maybe NodeTypeImpliedContent)}
  deriving (Eq, Ord, Read, Show)

_NodeKeyLabelSetWithContent = Core.Name "openGql.grammar.NodeKeyLabelSetWithContent"

_NodeKeyLabelSetWithContent_keyLabelSet = Core.Name "keyLabelSet"

_NodeKeyLabelSetWithContent_impliedContent = Core.Name "impliedContent"

-- | A GQL node label set with properties
data NodeLabelSetWithProperties =
  NodeLabelSetWithProperties {
    nodeLabelSetWithPropertiesLabelSet :: NodeTypeLabelSet,
    nodeLabelSetWithPropertiesPropertyTypes :: NodeTypePropertyTypes}
  deriving (Eq, Ord, Read, Show)

_NodeLabelSetWithProperties = Core.Name "openGql.grammar.NodeLabelSetWithProperties"

_NodeLabelSetWithProperties_labelSet = Core.Name "labelSet"

_NodeLabelSetWithProperties_propertyTypes = Core.Name "propertyTypes"

-- | A GQL node pattern, equivalent to a element pattern filler
type NodePattern = ElementPatternFiller

_NodePattern = Core.Name "openGql.grammar.NodePattern"

-- | A GQL node reference, equivalent to a element variable reference
type NodeReference = ElementVariableReference

_NodeReference = Core.Name "openGql.grammar.NodeReference"

-- | A GQL node reference value expression, equivalent to a primary value expression
type NodeReferenceValueExpression = PrimaryValueExpression

_NodeReferenceValueExpression = Core.Name "openGql.grammar.NodeReferenceValueExpression"

-- | A GQL node reference value type: one of several alternative forms
data NodeReferenceValueType =
  NodeReferenceValueTypeOpen OpenNodeReferenceValueType |
  NodeReferenceValueTypeClosed ClosedNodeReferenceValueType
  deriving (Eq, Ord, Read, Show)

_NodeReferenceValueType = Core.Name "openGql.grammar.NodeReferenceValueType"

_NodeReferenceValueType_open = Core.Name "open"

_NodeReferenceValueType_closed = Core.Name "closed"

-- | A GQL node synonym: one of a fixed set of alternatives
data NodeSynonym =
  NodeSynonymNode |
  NodeSynonymVertex
  deriving (Eq, Ord, Read, Show)

_NodeSynonym = Core.Name "openGql.grammar.NodeSynonym"

_NodeSynonym_node = Core.Name "node"

_NodeSynonym_vertex = Core.Name "vertex"

-- | A GQL node synonym and type name
data NodeSynonymAndTypeName =
  NodeSynonymAndTypeName {
    nodeSynonymAndTypeNameNodeSynonym :: NodeSynonym,
    nodeSynonymAndTypeNameTypeName :: (Maybe NodeTypeName)}
  deriving (Eq, Ord, Read, Show)

_NodeSynonymAndTypeName = Core.Name "openGql.grammar.NodeSynonymAndTypeName"

_NodeSynonymAndTypeName_nodeSynonym = Core.Name "nodeSynonym"

_NodeSynonymAndTypeName_typeName = Core.Name "typeName"

-- | A GQL node type filler: one of several alternative forms
data NodeTypeFiller =
  NodeTypeFillerKeyLabelSet NodeKeyLabelSetWithContent |
  NodeTypeFillerImpliedContent NodeTypeImpliedContent
  deriving (Eq, Ord, Read, Show)

_NodeTypeFiller = Core.Name "openGql.grammar.NodeTypeFiller"

_NodeTypeFiller_keyLabelSet = Core.Name "keyLabelSet"

_NodeTypeFiller_impliedContent = Core.Name "impliedContent"

-- | A GQL node type implied content: one of several alternative forms
data NodeTypeImpliedContent =
  NodeTypeImpliedContentLabelSet NodeTypeLabelSet |
  NodeTypeImpliedContentPropertyTypes NodeTypePropertyTypes |
  NodeTypeImpliedContentLabelSetWithProperties NodeLabelSetWithProperties
  deriving (Eq, Ord, Read, Show)

_NodeTypeImpliedContent = Core.Name "openGql.grammar.NodeTypeImpliedContent"

_NodeTypeImpliedContent_labelSet = Core.Name "labelSet"

_NodeTypeImpliedContent_propertyTypes = Core.Name "propertyTypes"

_NodeTypeImpliedContent_labelSetWithProperties = Core.Name "labelSetWithProperties"

-- | An optional GQL node type key label set
type NodeTypeKeyLabelSet = (Maybe LabelSetPhrase)

_NodeTypeKeyLabelSet = Core.Name "openGql.grammar.NodeTypeKeyLabelSet"

-- | A GQL node type label set, equivalent to a label set phrase
type NodeTypeLabelSet = LabelSetPhrase

_NodeTypeLabelSet = Core.Name "openGql.grammar.NodeTypeLabelSet"

-- | A GQL node type name
type NodeTypeName = String

_NodeTypeName = Core.Name "openGql.grammar.NodeTypeName"

-- | A GQL node type name with filler
data NodeTypeNameWithFiller =
  NodeTypeNameWithFiller {
    nodeTypeNameWithFillerTypeName :: NodeTypeName,
    nodeTypeNameWithFillerFiller :: (Maybe NodeTypeFiller)}
  deriving (Eq, Ord, Read, Show)

_NodeTypeNameWithFiller = Core.Name "openGql.grammar.NodeTypeNameWithFiller"

_NodeTypeNameWithFiller_typeName = Core.Name "typeName"

_NodeTypeNameWithFiller_filler = Core.Name "filler"

-- | A GQL node type pattern
data NodeTypePattern =
  NodeTypePattern {
    nodeTypePatternSynonymAndTypeName :: (Maybe NodeSynonymAndTypeName),
    nodeTypePatternAlias :: (Maybe LocalNodeTypeAlias),
    nodeTypePatternFiller :: (Maybe NodeTypeFiller)}
  deriving (Eq, Ord, Read, Show)

_NodeTypePattern = Core.Name "openGql.grammar.NodeTypePattern"

_NodeTypePattern_synonymAndTypeName = Core.Name "synonymAndTypeName"

_NodeTypePattern_alias = Core.Name "alias"

_NodeTypePattern_filler = Core.Name "filler"

-- | A GQL node type phrase
data NodeTypePhrase =
  NodeTypePhrase {
    nodeTypePhraseSynonym :: NodeSynonym,
    nodeTypePhraseTypePhraseFiller :: NodeTypePhraseFiller,
    nodeTypePhraseAlias :: (Maybe LocalNodeTypeAlias)}
  deriving (Eq, Ord, Read, Show)

_NodeTypePhrase = Core.Name "openGql.grammar.NodeTypePhrase"

_NodeTypePhrase_synonym = Core.Name "synonym"

_NodeTypePhrase_typePhraseFiller = Core.Name "typePhraseFiller"

_NodeTypePhrase_alias = Core.Name "alias"

-- | A GQL node type phrase filler: one of several alternative forms
data NodeTypePhraseFiller =
  NodeTypePhraseFillerTypeName NodeTypeNameWithFiller |
  NodeTypePhraseFillerFillerOnly NodeTypeFiller
  deriving (Eq, Ord, Read, Show)

_NodeTypePhraseFiller = Core.Name "openGql.grammar.NodeTypePhraseFiller"

_NodeTypePhraseFiller_typeName = Core.Name "typeName"

_NodeTypePhraseFiller_fillerOnly = Core.Name "fillerOnly"

-- | A GQL node type property types, equivalent to a property types specification
type NodeTypePropertyTypes = PropertyTypesSpecification

_NodeTypePropertyTypes = Core.Name "openGql.grammar.NodeTypePropertyTypes"

-- | A GQL node type specification: one of several alternative forms
data NodeTypeSpecification =
  NodeTypeSpecificationPattern NodeTypePattern |
  NodeTypeSpecificationPhrase NodeTypePhrase
  deriving (Eq, Ord, Read, Show)

_NodeTypeSpecification = Core.Name "openGql.grammar.NodeTypeSpecification"

_NodeTypeSpecification_pattern = Core.Name "pattern"

_NodeTypeSpecification_phrase = Core.Name "phrase"

-- | A GQL non negative integer specification: one of several alternative forms
data NonNegativeIntegerSpecification =
  NonNegativeIntegerSpecificationUnsignedInteger UnsignedInteger |
  NonNegativeIntegerSpecificationDynamicParameterSpecification DynamicParameterSpecification
  deriving (Eq, Ord, Read, Show)

_NonNegativeIntegerSpecification = Core.Name "openGql.grammar.NonNegativeIntegerSpecification"

_NonNegativeIntegerSpecification_unsignedInteger = Core.Name "unsignedInteger"

_NonNegativeIntegerSpecification_dynamicParameterSpecification = Core.Name "dynamicParameterSpecification"

-- | A GQL non parenthesized primary value expression: one of several alternative forms
data NonParenthesizedPrimaryValueExpression =
  NonParenthesizedPrimaryValueExpressionSpecial NonParenthesizedPrimaryValueExpressionSpecialCase |
  NonParenthesizedPrimaryValueExpressionBindingVariable BindingVariableReference
  deriving (Eq, Ord, Read, Show)

_NonParenthesizedPrimaryValueExpression = Core.Name "openGql.grammar.NonParenthesizedPrimaryValueExpression"

_NonParenthesizedPrimaryValueExpression_special = Core.Name "special"

_NonParenthesizedPrimaryValueExpression_bindingVariable = Core.Name "bindingVariable"

-- | A GQL non parenthesized primary value expression special case: one of several alternative forms
data NonParenthesizedPrimaryValueExpressionSpecialCase =
  NonParenthesizedPrimaryValueExpressionSpecialCaseAggregateFunction AggregateFunction |
  NonParenthesizedPrimaryValueExpressionSpecialCaseUnsignedValueSpecification UnsignedValueSpecification |
  NonParenthesizedPrimaryValueExpressionSpecialCasePathValueConstructor PathValueConstructor |
  NonParenthesizedPrimaryValueExpressionSpecialCasePropertyReference PropertyReference |
  NonParenthesizedPrimaryValueExpressionSpecialCaseValueQueryExpression ValueQueryExpression |
  NonParenthesizedPrimaryValueExpressionSpecialCaseCaseExpression CaseExpression |
  NonParenthesizedPrimaryValueExpressionSpecialCaseCastSpecification CastSpecification |
  NonParenthesizedPrimaryValueExpressionSpecialCaseElementIdFunction ElementIdFunction |
  NonParenthesizedPrimaryValueExpressionSpecialCaseLetValueExpression LetValueExpression
  deriving (Eq, Ord, Read, Show)

_NonParenthesizedPrimaryValueExpressionSpecialCase =
    Core.Name "openGql.grammar.NonParenthesizedPrimaryValueExpressionSpecialCase"

_NonParenthesizedPrimaryValueExpressionSpecialCase_aggregateFunction = Core.Name "aggregateFunction"

_NonParenthesizedPrimaryValueExpressionSpecialCase_unsignedValueSpecification = Core.Name "unsignedValueSpecification"

_NonParenthesizedPrimaryValueExpressionSpecialCase_pathValueConstructor = Core.Name "pathValueConstructor"

_NonParenthesizedPrimaryValueExpressionSpecialCase_propertyReference = Core.Name "propertyReference"

_NonParenthesizedPrimaryValueExpressionSpecialCase_valueQueryExpression = Core.Name "valueQueryExpression"

_NonParenthesizedPrimaryValueExpressionSpecialCase_caseExpression = Core.Name "caseExpression"

_NonParenthesizedPrimaryValueExpressionSpecialCase_castSpecification = Core.Name "castSpecification"

_NonParenthesizedPrimaryValueExpressionSpecialCase_elementIdFunction = Core.Name "elementIdFunction"

_NonParenthesizedPrimaryValueExpressionSpecialCase_letValueExpression = Core.Name "letValueExpression"

-- | A GQL normal form: one of a fixed set of alternatives
data NormalForm =
  NormalFormNfc |
  NormalFormNfd |
  NormalFormNfkc |
  NormalFormNfkd
  deriving (Eq, Ord, Read, Show)

_NormalForm = Core.Name "openGql.grammar.NormalForm"

_NormalForm_nfc = Core.Name "nfc"

_NormalForm_nfd = Core.Name "nfd"

_NormalForm_nfkc = Core.Name "nfkc"

_NormalForm_nfkd = Core.Name "nfkd"

-- | A GQL normalize character string
data NormalizeCharacterString =
  NormalizeCharacterString {
    normalizeCharacterStringValueExpression :: ValueExpression,
    normalizeCharacterStringNormalForm :: (Maybe NormalForm)}
  deriving (Eq, Ord, Read, Show)

_NormalizeCharacterString = Core.Name "openGql.grammar.NormalizeCharacterString"

_NormalizeCharacterString_valueExpression = Core.Name "valueExpression"

_NormalizeCharacterString_normalForm = Core.Name "normalForm"

-- | A GQL normalized predicate expression
data NormalizedPredicateExpr =
  NormalizedPredicateExpr {
    normalizedPredicateExprValueExpression :: ValueExpression,
    normalizedPredicateExprNormalizedPredicate :: NormalizedPredicatePart2}
  deriving (Eq, Ord, Read, Show)

_NormalizedPredicateExpr = Core.Name "openGql.grammar.NormalizedPredicateExpr"

_NormalizedPredicateExpr_valueExpression = Core.Name "valueExpression"

_NormalizedPredicateExpr_normalizedPredicate = Core.Name "normalizedPredicate"

-- | A GQL normalized predicate part2
data NormalizedPredicatePart2 =
  NormalizedPredicatePart2 {
    normalizedPredicatePart2Not :: Bool,
    normalizedPredicatePart2NormalForm :: (Maybe NormalForm)}
  deriving (Eq, Ord, Read, Show)

_NormalizedPredicatePart2 = Core.Name "openGql.grammar.NormalizedPredicatePart2"

_NormalizedPredicatePart2_not = Core.Name "not"

_NormalizedPredicatePart2_normalForm = Core.Name "normalForm"

-- | A GQL not expression, equivalent to a value expression
type NotExpr = ValueExpression

_NotExpr = Core.Name "openGql.grammar.NotExpr"

-- | A GQL not null
type NotNull = ()

_NotNull = Core.Name "openGql.grammar.NotNull"

-- | A GQL null if abbreviation
data NullIfAbbreviation =
  NullIfAbbreviation {
    nullIfAbbreviationFirst :: ValueExpression,
    nullIfAbbreviationSecond :: ValueExpression}
  deriving (Eq, Ord, Read, Show)

_NullIfAbbreviation = Core.Name "openGql.grammar.NullIfAbbreviation"

_NullIfAbbreviation_first = Core.Name "first"

_NullIfAbbreviation_second = Core.Name "second"

-- | A GQL null literal
type NullLiteral = ()

_NullLiteral = Core.Name "openGql.grammar.NullLiteral"

-- | A GQL null ordering: one of a fixed set of alternatives
data NullOrdering =
  NullOrderingNullsFirst |
  NullOrderingNullsLast
  deriving (Eq, Ord, Read, Show)

_NullOrdering = Core.Name "openGql.grammar.NullOrdering"

_NullOrdering_nullsFirst = Core.Name "nullsFirst"

_NullOrdering_nullsLast = Core.Name "nullsLast"

-- | A GQL null predicate
data NullPredicate =
  NullPredicate {
    nullPredicateValueExpression :: PrimaryValueExpression,
    nullPredicateNullPart :: NullPredicatePart2}
  deriving (Eq, Ord, Read, Show)

_NullPredicate = Core.Name "openGql.grammar.NullPredicate"

_NullPredicate_valueExpression = Core.Name "valueExpression"

_NullPredicate_nullPart = Core.Name "nullPart"

-- | A GQL null predicate part2
data NullPredicatePart2 =
  NullPredicatePart2 {
    nullPredicatePart2Not :: Bool}
  deriving (Eq, Ord, Read, Show)

_NullPredicatePart2 = Core.Name "openGql.grammar.NullPredicatePart2"

_NullPredicatePart2_not = Core.Name "not"

-- | A GQL null type
type NullType = ()

_NullType = Core.Name "openGql.grammar.NullType"

-- | A GQL number of groups, equivalent to a non negative integer specification
type NumberOfGroups = NonNegativeIntegerSpecification

_NumberOfGroups = Core.Name "openGql.grammar.NumberOfGroups"

-- | A GQL number of paths, equivalent to a non negative integer specification
type NumberOfPaths = NonNegativeIntegerSpecification

_NumberOfPaths = Core.Name "openGql.grammar.NumberOfPaths"

-- | A GQL numeric type: one of several alternative forms
data NumericType =
  NumericTypeExact ExactNumericType |
  NumericTypeApproximate ApproximateNumericType
  deriving (Eq, Ord, Read, Show)

_NumericType = Core.Name "openGql.grammar.NumericType"

_NumericType_exact = Core.Name "exact"

_NumericType_approximate = Core.Name "approximate"

-- | A GQL numeric value expression: one of several alternative forms
data NumericValueExpression =
  NumericValueExpressionSigned SignedNumericValueExpression |
  NumericValueExpressionMultiplicationOrDivision MulDivNumericValueExpression |
  NumericValueExpressionAdditionOrSubtraction AddSubNumericValueExpression |
  NumericValueExpressionPrimary PrimaryValueExpression |
  NumericValueExpressionFunction NumericValueFunction
  deriving (Eq, Ord, Read, Show)

_NumericValueExpression = Core.Name "openGql.grammar.NumericValueExpression"

_NumericValueExpression_signed = Core.Name "signed"

_NumericValueExpression_multiplicationOrDivision = Core.Name "multiplicationOrDivision"

_NumericValueExpression_additionOrSubtraction = Core.Name "additionOrSubtraction"

_NumericValueExpression_primary = Core.Name "primary"

_NumericValueExpression_function = Core.Name "function"

-- | A GQL numeric value expression base, equivalent to a numeric value expression
type NumericValueExpressionBase = NumericValueExpression

_NumericValueExpressionBase = Core.Name "openGql.grammar.NumericValueExpressionBase"

-- | A GQL numeric value expression dividend, equivalent to a numeric value expression
type NumericValueExpressionDividend = NumericValueExpression

_NumericValueExpressionDividend = Core.Name "openGql.grammar.NumericValueExpressionDividend"

-- | A GQL numeric value expression divisor, equivalent to a numeric value expression
type NumericValueExpressionDivisor = NumericValueExpression

_NumericValueExpressionDivisor = Core.Name "openGql.grammar.NumericValueExpressionDivisor"

-- | A GQL numeric value expression exponent, equivalent to a numeric value expression
type NumericValueExpressionExponent = NumericValueExpression

_NumericValueExpressionExponent = Core.Name "openGql.grammar.NumericValueExpressionExponent"

-- | A GQL numeric value function: one of several alternative forms
data NumericValueFunction =
  NumericValueFunctionLength LengthExpression |
  NumericValueFunctionCardinality CardinalityExpression |
  NumericValueFunctionAbsoluteValue AbsoluteValueExpression |
  NumericValueFunctionModulus ModulusExpression |
  NumericValueFunctionTrigonometric TrigonometricFunction |
  NumericValueFunctionLogarithm GeneralLogarithmFunction |
  NumericValueFunctionCommonLogarithm CommonLogarithm |
  NumericValueFunctionNaturalLogarithm NaturalLogarithm |
  NumericValueFunctionExponential ExponentialFunction |
  NumericValueFunctionPower PowerFunction |
  NumericValueFunctionSquareRoot SquareRoot |
  NumericValueFunctionFloor FloorFunction |
  NumericValueFunctionCeiling CeilingFunction
  deriving (Eq, Ord, Read, Show)

_NumericValueFunction = Core.Name "openGql.grammar.NumericValueFunction"

_NumericValueFunction_length = Core.Name "length"

_NumericValueFunction_cardinality = Core.Name "cardinality"

_NumericValueFunction_absoluteValue = Core.Name "absoluteValue"

_NumericValueFunction_modulus = Core.Name "modulus"

_NumericValueFunction_trigonometric = Core.Name "trigonometric"

_NumericValueFunction_logarithm = Core.Name "logarithm"

_NumericValueFunction_commonLogarithm = Core.Name "commonLogarithm"

_NumericValueFunction_naturalLogarithm = Core.Name "naturalLogarithm"

_NumericValueFunction_exponential = Core.Name "exponential"

_NumericValueFunction_power = Core.Name "power"

_NumericValueFunction_squareRoot = Core.Name "squareRoot"

_NumericValueFunction_floor = Core.Name "floor"

_NumericValueFunction_ceiling = Core.Name "ceiling"

-- | A GQL object expression primary: one of several alternative forms
data ObjectExpressionPrimary =
  ObjectExpressionPrimaryVariable PrimaryValueExpression |
  ObjectExpressionPrimaryParenthesized ParenthesizedValueExpression |
  ObjectExpressionPrimaryNonParenthesized NonParenthesizedPrimaryValueExpressionSpecialCase
  deriving (Eq, Ord, Read, Show)

_ObjectExpressionPrimary = Core.Name "openGql.grammar.ObjectExpressionPrimary"

_ObjectExpressionPrimary_variable = Core.Name "variable"

_ObjectExpressionPrimary_parenthesized = Core.Name "parenthesized"

_ObjectExpressionPrimary_nonParenthesized = Core.Name "nonParenthesized"

-- | A GQL object name
type ObjectName = String

_ObjectName = Core.Name "openGql.grammar.ObjectName"

-- | A GQL object name or binding variable
type ObjectNameOrBindingVariable = String

_ObjectNameOrBindingVariable = Core.Name "openGql.grammar.ObjectNameOrBindingVariable"

-- | A GQL of graph type: one of several alternative forms
data OfGraphType =
  OfGraphTypeLikeGraph GraphTypeLikeGraph |
  OfGraphTypeReference TypedGraphTypeReference |
  OfGraphTypeNested TypedNestedGraphTypeSpecification
  deriving (Eq, Ord, Read, Show)

_OfGraphType = Core.Name "openGql.grammar.OfGraphType"

_OfGraphType_likeGraph = Core.Name "likeGraph"

_OfGraphType_reference = Core.Name "reference"

_OfGraphType_nested = Core.Name "nested"

-- | A GQL offset and optional limit
data OffsetAndOptionalLimit =
  OffsetAndOptionalLimit {
    offsetAndOptionalLimitOffset :: OffsetClause,
    offsetAndOptionalLimitLimit :: (Maybe LimitClause)}
  deriving (Eq, Ord, Read, Show)

_OffsetAndOptionalLimit = Core.Name "openGql.grammar.OffsetAndOptionalLimit"

_OffsetAndOptionalLimit_offset = Core.Name "offset"

_OffsetAndOptionalLimit_limit = Core.Name "limit"

-- | A GQL offset clause
data OffsetClause =
  OffsetClause {
    offsetClauseSynonym :: OffsetSynonym,
    offsetClauseValue :: NonNegativeIntegerSpecification}
  deriving (Eq, Ord, Read, Show)

_OffsetClause = Core.Name "openGql.grammar.OffsetClause"

_OffsetClause_synonym = Core.Name "synonym"

_OffsetClause_value = Core.Name "value"

-- | A GQL offset synonym: one of a fixed set of alternatives
data OffsetSynonym =
  OffsetSynonymOffset |
  OffsetSynonymSkipReservedWord
  deriving (Eq, Ord, Read, Show)

_OffsetSynonym = Core.Name "openGql.grammar.OffsetSynonym"

_OffsetSynonym_offset = Core.Name "offset"

_OffsetSynonym_skipReservedWord = Core.Name "skipReservedWord"

-- | A GQL open dynamic union type
data OpenDynamicUnionType =
  OpenDynamicUnionType {
    openDynamicUnionTypeValue :: Bool,
    openDynamicUnionTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_OpenDynamicUnionType = Core.Name "openGql.grammar.OpenDynamicUnionType"

_OpenDynamicUnionType_value = Core.Name "value"

_OpenDynamicUnionType_notNull = Core.Name "notNull"

-- | A GQL open edge reference value type
data OpenEdgeReferenceValueType =
  OpenEdgeReferenceValueType {
    openEdgeReferenceValueTypeAny :: Bool,
    openEdgeReferenceValueTypeEdgeSynonym :: EdgeSynonym,
    openEdgeReferenceValueTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_OpenEdgeReferenceValueType = Core.Name "openGql.grammar.OpenEdgeReferenceValueType"

_OpenEdgeReferenceValueType_any = Core.Name "any"

_OpenEdgeReferenceValueType_edgeSynonym = Core.Name "edgeSynonym"

_OpenEdgeReferenceValueType_notNull = Core.Name "notNull"

-- | A GQL open graph reference value type
data OpenGraphReferenceValueType =
  OpenGraphReferenceValueType {
    openGraphReferenceValueTypeAny :: (Maybe Bool),
    openGraphReferenceValueTypeProperty :: Bool,
    openGraphReferenceValueTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_OpenGraphReferenceValueType = Core.Name "openGql.grammar.OpenGraphReferenceValueType"

_OpenGraphReferenceValueType_any = Core.Name "any"

_OpenGraphReferenceValueType_property = Core.Name "property"

_OpenGraphReferenceValueType_notNull = Core.Name "notNull"

-- | A GQL open graph type
data OpenGraphType =
  OpenGraphType {
    openGraphTypeTyped :: (Maybe Typed),
    openGraphTypeGraph :: Bool}
  deriving (Eq, Ord, Read, Show)

_OpenGraphType = Core.Name "openGql.grammar.OpenGraphType"

_OpenGraphType_typed = Core.Name "typed"

_OpenGraphType_graph = Core.Name "graph"

-- | A GQL open node reference value type
data OpenNodeReferenceValueType =
  OpenNodeReferenceValueType {
    openNodeReferenceValueTypeAny :: Bool,
    openNodeReferenceValueTypeNodeSynonym :: NodeSynonym,
    openNodeReferenceValueTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_OpenNodeReferenceValueType = Core.Name "openGql.grammar.OpenNodeReferenceValueType"

_OpenNodeReferenceValueType_any = Core.Name "any"

_OpenNodeReferenceValueType_nodeSynonym = Core.Name "nodeSynonym"

_OpenNodeReferenceValueType_notNull = Core.Name "notNull"

-- | A GQL opt typed binding table initializer
data OptTypedBindingTableInitializer =
  OptTypedBindingTableInitializer {
    optTypedBindingTableInitializerType :: (Maybe TypedBindingTableReferenceValueType),
    optTypedBindingTableInitializerInitializer :: BindingTableInitializer}
  deriving (Eq, Ord, Read, Show)

_OptTypedBindingTableInitializer = Core.Name "openGql.grammar.OptTypedBindingTableInitializer"

_OptTypedBindingTableInitializer_type = Core.Name "type"

_OptTypedBindingTableInitializer_initializer = Core.Name "initializer"

-- | A GQL opt typed graph initializer
data OptTypedGraphInitializer =
  OptTypedGraphInitializer {
    optTypedGraphInitializerType :: (Maybe TypedGraphReferenceValueType),
    optTypedGraphInitializerInitializer :: GraphInitializer}
  deriving (Eq, Ord, Read, Show)

_OptTypedGraphInitializer = Core.Name "openGql.grammar.OptTypedGraphInitializer"

_OptTypedGraphInitializer_type = Core.Name "type"

_OptTypedGraphInitializer_initializer = Core.Name "initializer"

-- | A GQL opt typed value initializer
data OptTypedValueInitializer =
  OptTypedValueInitializer {
    optTypedValueInitializerType :: (Maybe TypedValueType),
    optTypedValueInitializerInitializer :: ValueInitializer}
  deriving (Eq, Ord, Read, Show)

_OptTypedValueInitializer = Core.Name "openGql.grammar.OptTypedValueInitializer"

_OptTypedValueInitializer_type = Core.Name "type"

_OptTypedValueInitializer_initializer = Core.Name "initializer"

-- | A GQL optional match statement, equivalent to a optional operand
type OptionalMatchStatement = OptionalOperand

_OptionalMatchStatement = Core.Name "openGql.grammar.OptionalMatchStatement"

-- | A GQL optional operand: one of several alternative forms
data OptionalOperand =
  OptionalOperandSimple SimpleMatchStatement |
  OptionalOperandBraceBlock MatchStatementBlock |
  OptionalOperandParenBlock MatchStatementBlock
  deriving (Eq, Ord, Read, Show)

_OptionalOperand = Core.Name "openGql.grammar.OptionalOperand"

_OptionalOperand_simple = Core.Name "simple"

_OptionalOperand_braceBlock = Core.Name "braceBlock"

_OptionalOperand_parenBlock = Core.Name "parenBlock"

-- | A GQL order by and optional offset and limit
data OrderByAndOptionalOffsetAndLimit =
  OrderByAndOptionalOffsetAndLimit {
    orderByAndOptionalOffsetAndLimitOrderBy :: OrderByClause,
    orderByAndOptionalOffsetAndLimitOffset :: (Maybe OffsetClause),
    orderByAndOptionalOffsetAndLimitLimit :: (Maybe LimitClause)}
  deriving (Eq, Ord, Read, Show)

_OrderByAndOptionalOffsetAndLimit = Core.Name "openGql.grammar.OrderByAndOptionalOffsetAndLimit"

_OrderByAndOptionalOffsetAndLimit_orderBy = Core.Name "orderBy"

_OrderByAndOptionalOffsetAndLimit_offset = Core.Name "offset"

_OrderByAndOptionalOffsetAndLimit_limit = Core.Name "limit"

-- | A GQL order by and page statement: one of several alternative forms
data OrderByAndPageStatement =
  OrderByAndPageStatementOrderByAndOptionalOffsetAndLimit OrderByAndOptionalOffsetAndLimit |
  OrderByAndPageStatementOffsetAndOptionalLimit OffsetAndOptionalLimit |
  OrderByAndPageStatementLimitOnly LimitClause
  deriving (Eq, Ord, Read, Show)

_OrderByAndPageStatement = Core.Name "openGql.grammar.OrderByAndPageStatement"

_OrderByAndPageStatement_orderByAndOptionalOffsetAndLimit = Core.Name "orderByAndOptionalOffsetAndLimit"

_OrderByAndPageStatement_offsetAndOptionalLimit = Core.Name "offsetAndOptionalLimit"

_OrderByAndPageStatement_limitOnly = Core.Name "limitOnly"

-- | A GQL order by clause, equivalent to a sort specification list
type OrderByClause = SortSpecificationList

_OrderByClause = Core.Name "openGql.grammar.OrderByClause"

-- | A GQL ordering specification: one of a fixed set of alternatives
data OrderingSpecification =
  OrderingSpecificationAscending |
  OrderingSpecificationDescending
  deriving (Eq, Ord, Read, Show)

_OrderingSpecification = Core.Name "openGql.grammar.OrderingSpecification"

_OrderingSpecification_ascending = Core.Name "ascending"

_OrderingSpecification_descending = Core.Name "descending"

-- | A GQL ordinality or offset type: one of a fixed set of alternatives
data OrdinalityOrOffsetType =
  OrdinalityOrOffsetTypeOrdinality |
  OrdinalityOrOffsetTypeOffset
  deriving (Eq, Ord, Read, Show)

_OrdinalityOrOffsetType = Core.Name "openGql.grammar.OrdinalityOrOffsetType"

_OrdinalityOrOffsetType_ordinality = Core.Name "ordinality"

_OrdinalityOrOffsetType_offset = Core.Name "offset"

-- | A GQL parameter name
type ParameterName = String

_ParameterName = Core.Name "openGql.grammar.ParameterName"

-- | A GQL parameter session specification
data ParameterSessionSpecification =
  ParameterSessionSpecification {
    parameterSessionSpecificationParameter :: Bool,
    parameterSessionSpecificationSessionParameterSpecification :: SessionParameterSpecification}
  deriving (Eq, Ord, Read, Show)

_ParameterSessionSpecification = Core.Name "openGql.grammar.ParameterSessionSpecification"

_ParameterSessionSpecification_parameter = Core.Name "parameter"

_ParameterSessionSpecification_sessionParameterSpecification = Core.Name "sessionParameterSpecification"

-- | A GQL parameters or characteristics: one of a fixed set of alternatives
data ParametersOrCharacteristics =
  ParametersOrCharacteristicsParameters |
  ParametersOrCharacteristicsCharacteristics
  deriving (Eq, Ord, Read, Show)

_ParametersOrCharacteristics = Core.Name "openGql.grammar.ParametersOrCharacteristics"

_ParametersOrCharacteristics_parameters = Core.Name "parameters"

_ParametersOrCharacteristics_characteristics = Core.Name "characteristics"

-- | A GQL parent and graph name
data ParentAndGraphName =
  ParentAndGraphName {
    parentAndGraphNameParentReference :: CatalogObjectParentReference,
    parentAndGraphNameGraphName :: GraphName}
  deriving (Eq, Ord, Read, Show)

_ParentAndGraphName = Core.Name "openGql.grammar.ParentAndGraphName"

_ParentAndGraphName_parentReference = Core.Name "parentReference"

_ParentAndGraphName_graphName = Core.Name "graphName"

-- | A GQL parent and table name
data ParentAndTableName =
  ParentAndTableName {
    parentAndTableNameParentReference :: CatalogObjectParentReference,
    parentAndTableNameTableName :: BindingTableName}
  deriving (Eq, Ord, Read, Show)

_ParentAndTableName = Core.Name "openGql.grammar.ParentAndTableName"

_ParentAndTableName_parentReference = Core.Name "parentReference"

_ParentAndTableName_tableName = Core.Name "tableName"

-- | A GQL parenthesized path pattern expression
data ParenthesizedPathPatternExpression =
  ParenthesizedPathPatternExpression {
    parenthesizedPathPatternExpressionSubpathDeclaration :: (Maybe SubpathVariableDeclaration),
    parenthesizedPathPatternExpressionPathMode :: (Maybe PathModePrefix),
    parenthesizedPathPatternExpressionExpression :: PathPatternExpression,
    parenthesizedPathPatternExpressionWhereClause :: (Maybe ParenthesizedPathPatternWhereClause)}
  deriving (Eq, Ord, Read, Show)

_ParenthesizedPathPatternExpression = Core.Name "openGql.grammar.ParenthesizedPathPatternExpression"

_ParenthesizedPathPatternExpression_subpathDeclaration = Core.Name "subpathDeclaration"

_ParenthesizedPathPatternExpression_pathMode = Core.Name "pathMode"

_ParenthesizedPathPatternExpression_expression = Core.Name "expression"

_ParenthesizedPathPatternExpression_whereClause = Core.Name "whereClause"

-- | A GQL parenthesized path pattern where clause, equivalent to a search condition
type ParenthesizedPathPatternWhereClause = SearchCondition

_ParenthesizedPathPatternWhereClause = Core.Name "openGql.grammar.ParenthesizedPathPatternWhereClause"

-- | A GQL parenthesized value expression, equivalent to a value expression
type ParenthesizedValueExpression = ValueExpression

_ParenthesizedValueExpression = Core.Name "openGql.grammar.ParenthesizedValueExpression"

-- | A GQL path element list
data PathElementList =
  PathElementList {
    pathElementListStart :: PathElementListStart,
    pathElementListSteps :: [PathElementListStep]}
  deriving (Eq, Ord, Read, Show)

_PathElementList = Core.Name "openGql.grammar.PathElementList"

_PathElementList_start = Core.Name "start"

_PathElementList_steps = Core.Name "steps"

-- | A GQL path element list start, equivalent to a node reference value expression
type PathElementListStart = NodeReferenceValueExpression

_PathElementListStart = Core.Name "openGql.grammar.PathElementListStart"

-- | A GQL path element list step
data PathElementListStep =
  PathElementListStep {
    pathElementListStepEdgeReference :: EdgeReferenceValueExpression,
    pathElementListStepNodeReference :: NodeReferenceValueExpression}
  deriving (Eq, Ord, Read, Show)

_PathElementListStep = Core.Name "openGql.grammar.PathElementListStep"

_PathElementListStep_edgeReference = Core.Name "edgeReference"

_PathElementListStep_nodeReference = Core.Name "nodeReference"

-- | A GQL path factor: one of several alternative forms
data PathFactor =
  PathFactorPrimary PathPrimary |
  PathFactorQuantifiedPrimary QuantifiedPathPrimary |
  PathFactorQuestionedPrimary QuestionedPathPrimary
  deriving (Eq, Ord, Read, Show)

_PathFactor = Core.Name "openGql.grammar.PathFactor"

_PathFactor_primary = Core.Name "primary"

_PathFactor_quantifiedPrimary = Core.Name "quantifiedPrimary"

_PathFactor_questionedPrimary = Core.Name "questionedPrimary"

-- | A GQL path length expression, equivalent to a path value expression
type PathLengthExpression = PathValueExpression

_PathLengthExpression = Core.Name "openGql.grammar.PathLengthExpression"

-- | A GQL path mode: one of a fixed set of alternatives
data PathMode =
  PathModeWalk |
  PathModeTrail |
  PathModeSimple |
  PathModeAcyclic
  deriving (Eq, Ord, Read, Show)

_PathMode = Core.Name "openGql.grammar.PathMode"

_PathMode_walk = Core.Name "walk"

_PathMode_trail = Core.Name "trail"

_PathMode_simple = Core.Name "simple"

_PathMode_acyclic = Core.Name "acyclic"

-- | A GQL path mode prefix
data PathModePrefix =
  PathModePrefix {
    pathModePrefixMode :: PathMode,
    pathModePrefixOrPaths :: (Maybe PathOrPaths)}
  deriving (Eq, Ord, Read, Show)

_PathModePrefix = Core.Name "openGql.grammar.PathModePrefix"

_PathModePrefix_mode = Core.Name "mode"

_PathModePrefix_orPaths = Core.Name "orPaths"

-- | A GQL path or paths: one of a fixed set of alternatives
data PathOrPaths =
  PathOrPathsPath |
  PathOrPathsPaths
  deriving (Eq, Ord, Read, Show)

_PathOrPaths = Core.Name "openGql.grammar.PathOrPaths"

_PathOrPaths_path = Core.Name "path"

_PathOrPaths_paths = Core.Name "paths"

-- | A GQL path pattern
data PathPattern =
  PathPattern {
    pathPatternVariableDeclaration :: (Maybe PathVariableDeclaration),
    pathPatternPrefix :: (Maybe PathPatternPrefix),
    pathPatternExpression :: PathPatternExpression}
  deriving (Eq, Ord, Read, Show)

_PathPattern = Core.Name "openGql.grammar.PathPattern"

_PathPattern_variableDeclaration = Core.Name "variableDeclaration"

_PathPattern_prefix = Core.Name "prefix"

_PathPattern_expression = Core.Name "expression"

-- | A GQL path pattern expression: one of several alternative forms
data PathPatternExpression =
  PathPatternExpressionTerm PathTerm |
  PathPatternExpressionMultisetAlternation [PathTerm] |
  PathPatternExpressionPatternUnion [PathTerm]
  deriving (Eq, Ord, Read, Show)

_PathPatternExpression = Core.Name "openGql.grammar.PathPatternExpression"

_PathPatternExpression_term = Core.Name "term"

_PathPatternExpression_multisetAlternation = Core.Name "multisetAlternation"

_PathPatternExpression_patternUnion = Core.Name "patternUnion"

-- | A list of GQL path pattern list elements
type PathPatternList = [PathPattern]

_PathPatternList = Core.Name "openGql.grammar.PathPatternList"

-- | A GQL path pattern prefix: one of several alternative forms
data PathPatternPrefix =
  PathPatternPrefixModePrefix PathModePrefix |
  PathPatternPrefixSearchPrefix PathSearchPrefix
  deriving (Eq, Ord, Read, Show)

_PathPatternPrefix = Core.Name "openGql.grammar.PathPatternPrefix"

_PathPatternPrefix_modePrefix = Core.Name "modePrefix"

_PathPatternPrefix_searchPrefix = Core.Name "searchPrefix"

-- | A GQL path primary: one of several alternative forms
data PathPrimary =
  PathPrimaryElementPattern ElementPattern |
  PathPrimaryParenthesizedExpression ParenthesizedPathPatternExpression |
  PathPrimarySimplifiedExpression SimplifiedPathPatternExpression
  deriving (Eq, Ord, Read, Show)

_PathPrimary = Core.Name "openGql.grammar.PathPrimary"

_PathPrimary_elementPattern = Core.Name "elementPattern"

_PathPrimary_parenthesizedExpression = Core.Name "parenthesizedExpression"

_PathPrimary_simplifiedExpression = Core.Name "simplifiedExpression"

-- | A GQL path search prefix: one of several alternative forms
data PathSearchPrefix =
  PathSearchPrefixAll AllPathSearch |
  PathSearchPrefixAny AnyPathSearch |
  PathSearchPrefixShortest ShortestPathSearch
  deriving (Eq, Ord, Read, Show)

_PathSearchPrefix = Core.Name "openGql.grammar.PathSearchPrefix"

_PathSearchPrefix_all = Core.Name "all"

_PathSearchPrefix_any = Core.Name "any"

_PathSearchPrefix_shortest = Core.Name "shortest"

-- | A list of GQL path term elements
type PathTerm = [PathFactor]

_PathTerm = Core.Name "openGql.grammar.PathTerm"

-- | A GQL path value constructor, equivalent to a path value constructor by enumeration
type PathValueConstructor = PathValueConstructorByEnumeration

_PathValueConstructor = Core.Name "openGql.grammar.PathValueConstructor"

-- | A GQL path value constructor by enumeration, equivalent to a path element list
type PathValueConstructorByEnumeration = PathElementList

_PathValueConstructorByEnumeration = Core.Name "openGql.grammar.PathValueConstructorByEnumeration"

-- | A GQL path value expression, equivalent to a value expression
type PathValueExpression = ValueExpression

_PathValueExpression = Core.Name "openGql.grammar.PathValueExpression"

-- | A GQL path value type
data PathValueType =
  PathValueType {
    pathValueTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_PathValueType = Core.Name "openGql.grammar.PathValueType"

_PathValueType_notNull = Core.Name "notNull"

-- | A GQL path variable, equivalent to a binding variable
type PathVariable = BindingVariable

_PathVariable = Core.Name "openGql.grammar.PathVariable"

-- | A GQL path variable declaration, equivalent to a path variable
type PathVariableDeclaration = PathVariable

_PathVariableDeclaration = Core.Name "openGql.grammar.PathVariableDeclaration"

-- | A GQL path variable reference, equivalent to a binding variable reference
type PathVariableReference = BindingVariableReference

_PathVariableReference = Core.Name "openGql.grammar.PathVariableReference"

-- | A GQL power function
data PowerFunction =
  PowerFunction {
    powerFunctionBase :: NumericValueExpressionBase,
    powerFunctionExponent :: NumericValueExpressionExponent}
  deriving (Eq, Ord, Read, Show)

_PowerFunction = Core.Name "openGql.grammar.PowerFunction"

_PowerFunction_base = Core.Name "base"

_PowerFunction_exponent = Core.Name "exponent"

-- | A GQL precision, equivalent to a unsigned decimal integer
type Precision = UnsignedDecimalInteger

_Precision = Core.Name "openGql.grammar.Precision"

-- | A GQL precision and scale
data PrecisionAndScale =
  PrecisionAndScale {
    precisionAndScalePrecision :: Precision,
    precisionAndScaleScale :: (Maybe Scale),
    precisionAndScaleNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_PrecisionAndScale = Core.Name "openGql.grammar.PrecisionAndScale"

_PrecisionAndScale_precision = Core.Name "precision"

_PrecisionAndScale_scale = Core.Name "scale"

_PrecisionAndScale_notNull = Core.Name "notNull"

-- | A GQL predefined schema reference: one of a fixed set of alternatives
data PredefinedSchemaReference =
  PredefinedSchemaReferenceHomeSchema |
  PredefinedSchemaReferenceCurrentSchema |
  PredefinedSchemaReferencePeriod
  deriving (Eq, Ord, Read, Show)

_PredefinedSchemaReference = Core.Name "openGql.grammar.PredefinedSchemaReference"

_PredefinedSchemaReference_homeSchema = Core.Name "homeSchema"

_PredefinedSchemaReference_currentSchema = Core.Name "currentSchema"

_PredefinedSchemaReference_period = Core.Name "period"

-- | A GQL predefined type: one of several alternative forms
data PredefinedType =
  PredefinedTypeBooleanType BooleanType |
  PredefinedTypeCharacterStringType CharacterStringType |
  PredefinedTypeByteStringType ByteStringType |
  PredefinedTypeNumericType NumericType |
  PredefinedTypeTemporalType TemporalType |
  PredefinedTypeReferenceValueType ReferenceValueType |
  PredefinedTypeImmaterialValueType ImmaterialValueType
  deriving (Eq, Ord, Read, Show)

_PredefinedType = Core.Name "openGql.grammar.PredefinedType"

_PredefinedType_booleanType = Core.Name "booleanType"

_PredefinedType_characterStringType = Core.Name "characterStringType"

_PredefinedType_byteStringType = Core.Name "byteStringType"

_PredefinedType_numericType = Core.Name "numericType"

_PredefinedType_temporalType = Core.Name "temporalType"

_PredefinedType_referenceValueType = Core.Name "referenceValueType"

_PredefinedType_immaterialValueType = Core.Name "immaterialValueType"

-- | A GQL predicate: one of several alternative forms
data Predicate =
  PredicateExistsPredicate ExistsPredicate |
  PredicateNullPredicate NullPredicate |
  PredicateValueTypePredicate ValueTypePredicate |
  PredicateDirectedPredicate DirectedPredicate |
  PredicateLabeledPredicate LabeledPredicate |
  PredicateSourceDestinationPredicate SourceDestinationPredicate |
  PredicateAllDifferentPredicate AllDifferentPredicate |
  PredicateSamePredicate SamePredicate |
  PredicatePropertyExistsPredicate PropertyExistsPredicate
  deriving (Eq, Ord, Read, Show)

_Predicate = Core.Name "openGql.grammar.Predicate"

_Predicate_existsPredicate = Core.Name "existsPredicate"

_Predicate_nullPredicate = Core.Name "nullPredicate"

_Predicate_valueTypePredicate = Core.Name "valueTypePredicate"

_Predicate_directedPredicate = Core.Name "directedPredicate"

_Predicate_labeledPredicate = Core.Name "labeledPredicate"

_Predicate_sourceDestinationPredicate = Core.Name "sourceDestinationPredicate"

_Predicate_allDifferentPredicate = Core.Name "allDifferentPredicate"

_Predicate_samePredicate = Core.Name "samePredicate"

_Predicate_propertyExistsPredicate = Core.Name "propertyExistsPredicate"

-- | A GQL primary value expression: one of several alternative forms
data PrimaryValueExpression =
  PrimaryValueExpressionParenthesized ParenthesizedValueExpression |
  PrimaryValueExpressionAggregateFunction AggregateFunction |
  PrimaryValueExpressionUnsignedValueSpecification UnsignedValueSpecification |
  PrimaryValueExpressionPathValueConstructor PathValueConstructor |
  PrimaryValueExpressionPropertyReference PropertyReference |
  PrimaryValueExpressionValueQueryExpression ValueQueryExpression |
  PrimaryValueExpressionCaseExpression CaseExpression |
  PrimaryValueExpressionCastSpecification CastSpecification |
  PrimaryValueExpressionElementIdFunction ElementIdFunction |
  PrimaryValueExpressionLetValueExpression LetValueExpression |
  PrimaryValueExpressionBindingVariableReference BindingVariableReference
  deriving (Eq, Ord, Read, Show)

_PrimaryValueExpression = Core.Name "openGql.grammar.PrimaryValueExpression"

_PrimaryValueExpression_parenthesized = Core.Name "parenthesized"

_PrimaryValueExpression_aggregateFunction = Core.Name "aggregateFunction"

_PrimaryValueExpression_unsignedValueSpecification = Core.Name "unsignedValueSpecification"

_PrimaryValueExpression_pathValueConstructor = Core.Name "pathValueConstructor"

_PrimaryValueExpression_propertyReference = Core.Name "propertyReference"

_PrimaryValueExpression_valueQueryExpression = Core.Name "valueQueryExpression"

_PrimaryValueExpression_caseExpression = Core.Name "caseExpression"

_PrimaryValueExpression_castSpecification = Core.Name "castSpecification"

_PrimaryValueExpression_elementIdFunction = Core.Name "elementIdFunction"

_PrimaryValueExpression_letValueExpression = Core.Name "letValueExpression"

_PrimaryValueExpression_bindingVariableReference = Core.Name "bindingVariableReference"

-- | A GQL primitive catalog modifying statement: one of several alternative forms
data PrimitiveCatalogModifyingStatement =
  PrimitiveCatalogModifyingStatementCreateSchema CreateSchemaStatement |
  PrimitiveCatalogModifyingStatementDropSchema DropSchemaStatement |
  PrimitiveCatalogModifyingStatementCreateGraph CreateGraphStatement |
  PrimitiveCatalogModifyingStatementDropGraph DropGraphStatement |
  PrimitiveCatalogModifyingStatementCreateGraphType CreateGraphTypeStatement |
  PrimitiveCatalogModifyingStatementDropGraphType DropGraphTypeStatement
  deriving (Eq, Ord, Read, Show)

_PrimitiveCatalogModifyingStatement = Core.Name "openGql.grammar.PrimitiveCatalogModifyingStatement"

_PrimitiveCatalogModifyingStatement_createSchema = Core.Name "createSchema"

_PrimitiveCatalogModifyingStatement_dropSchema = Core.Name "dropSchema"

_PrimitiveCatalogModifyingStatement_createGraph = Core.Name "createGraph"

_PrimitiveCatalogModifyingStatement_dropGraph = Core.Name "dropGraph"

_PrimitiveCatalogModifyingStatement_createGraphType = Core.Name "createGraphType"

_PrimitiveCatalogModifyingStatement_dropGraphType = Core.Name "dropGraphType"

-- | A GQL primitive data modifying statement: one of several alternative forms
data PrimitiveDataModifyingStatement =
  PrimitiveDataModifyingStatementInsert InsertStatement |
  PrimitiveDataModifyingStatementSet SetStatement |
  PrimitiveDataModifyingStatementRemove RemoveStatement |
  PrimitiveDataModifyingStatementDelete DeleteStatement
  deriving (Eq, Ord, Read, Show)

_PrimitiveDataModifyingStatement = Core.Name "openGql.grammar.PrimitiveDataModifyingStatement"

_PrimitiveDataModifyingStatement_insert = Core.Name "insert"

_PrimitiveDataModifyingStatement_set = Core.Name "set"

_PrimitiveDataModifyingStatement_remove = Core.Name "remove"

_PrimitiveDataModifyingStatement_delete = Core.Name "delete"

-- | A GQL primitive query statement: one of several alternative forms
data PrimitiveQueryStatement =
  PrimitiveQueryStatementMatch MatchStatement |
  PrimitiveQueryStatementLet LetStatement |
  PrimitiveQueryStatementFor ForStatement |
  PrimitiveQueryStatementFilter FilterStatement |
  PrimitiveQueryStatementOrderByAndPage OrderByAndPageStatement
  deriving (Eq, Ord, Read, Show)

_PrimitiveQueryStatement = Core.Name "openGql.grammar.PrimitiveQueryStatement"

_PrimitiveQueryStatement_match = Core.Name "match"

_PrimitiveQueryStatement_let = Core.Name "let"

_PrimitiveQueryStatement_for = Core.Name "for"

_PrimitiveQueryStatement_filter = Core.Name "filter"

_PrimitiveQueryStatement_orderByAndPage = Core.Name "orderByAndPage"

-- | A GQL primitive result statement: one of several alternative forms
data PrimitiveResultStatement =
  PrimitiveResultStatementReturnAndOptionalOrderBy ReturnAndOptionalOrderByAndPage |
  PrimitiveResultStatementFinish
  deriving (Eq, Ord, Read, Show)

_PrimitiveResultStatement = Core.Name "openGql.grammar.PrimitiveResultStatement"

_PrimitiveResultStatement_returnAndOptionalOrderBy = Core.Name "returnAndOptionalOrderBy"

_PrimitiveResultStatement_finish = Core.Name "finish"

-- | A GQL procedure and maybe end
data ProcedureAndMaybeEnd =
  ProcedureAndMaybeEnd {
    procedureAndMaybeEndProcedure :: ProcedureSpecification,
    procedureAndMaybeEndEnd :: (Maybe EndTransactionCommand)}
  deriving (Eq, Ord, Read, Show)

_ProcedureAndMaybeEnd = Core.Name "openGql.grammar.ProcedureAndMaybeEnd"

_ProcedureAndMaybeEnd_procedure = Core.Name "procedure"

_ProcedureAndMaybeEnd_end = Core.Name "end"

-- | A GQL procedure argument, equivalent to a value expression
type ProcedureArgument = ValueExpression

_ProcedureArgument = Core.Name "openGql.grammar.ProcedureArgument"

-- | A list of GQL procedure argument list elements
type ProcedureArgumentList = [ProcedureArgument]

_ProcedureArgumentList = Core.Name "openGql.grammar.ProcedureArgumentList"

-- | A GQL procedure body
data ProcedureBody =
  ProcedureBody {
    procedureBodyAtSchema :: (Maybe AtSchemaClause),
    procedureBodyBindings :: (Maybe BindingVariableDefinitionBlock),
    procedureBodyStatements :: StatementBlock}
  deriving (Eq, Ord, Read, Show)

_ProcedureBody = Core.Name "openGql.grammar.ProcedureBody"

_ProcedureBody_atSchema = Core.Name "atSchema"

_ProcedureBody_bindings = Core.Name "bindings"

_ProcedureBody_statements = Core.Name "statements"

-- | A GQL procedure call: one of several alternative forms
data ProcedureCall =
  ProcedureCallInline InlineProcedureCall |
  ProcedureCallNamed NamedProcedureCall
  deriving (Eq, Ord, Read, Show)

_ProcedureCall = Core.Name "openGql.grammar.ProcedureCall"

_ProcedureCall_inline = Core.Name "inline"

_ProcedureCall_named = Core.Name "named"

-- | A GQL procedure name
type ProcedureName = String

_ProcedureName = Core.Name "openGql.grammar.ProcedureName"

-- | A GQL procedure reference: one of several alternative forms
data ProcedureReference =
  ProcedureReferenceParentAndProcedureName CatalogProcedureParentAndName |
  ProcedureReferenceParameterSpecification ReferenceParameterSpecification
  deriving (Eq, Ord, Read, Show)

_ProcedureReference = Core.Name "openGql.grammar.ProcedureReference"

_ProcedureReference_parentAndProcedureName = Core.Name "parentAndProcedureName"

_ProcedureReference_parameterSpecification = Core.Name "parameterSpecification"

-- | A GQL procedure specification, equivalent to a procedure body
type ProcedureSpecification = ProcedureBody

_ProcedureSpecification = Core.Name "openGql.grammar.ProcedureSpecification"

-- | A GQL program activity: one of several alternative forms
data ProgramActivity =
  ProgramActivitySession SessionActivity |
  ProgramActivityTransaction TransactionActivity
  deriving (Eq, Ord, Read, Show)

_ProgramActivity = Core.Name "openGql.grammar.ProgramActivity"

_ProgramActivity_session = Core.Name "session"

_ProgramActivity_transaction = Core.Name "transaction"

-- | A GQL property exists predicate
data PropertyExistsPredicate =
  PropertyExistsPredicate {
    propertyExistsPredicateElementVariableReference :: ElementVariableReference,
    propertyExistsPredicatePropertyName :: PropertyName}
  deriving (Eq, Ord, Read, Show)

_PropertyExistsPredicate = Core.Name "openGql.grammar.PropertyExistsPredicate"

_PropertyExistsPredicate_elementVariableReference = Core.Name "elementVariableReference"

_PropertyExistsPredicate_propertyName = Core.Name "propertyName"

-- | A GQL property key value pair
data PropertyKeyValuePair =
  PropertyKeyValuePair {
    propertyKeyValuePairName :: PropertyName,
    propertyKeyValuePairValue :: ValueExpression}
  deriving (Eq, Ord, Read, Show)

_PropertyKeyValuePair = Core.Name "openGql.grammar.PropertyKeyValuePair"

_PropertyKeyValuePair_name = Core.Name "name"

_PropertyKeyValuePair_value = Core.Name "value"

-- | A list of GQL property key value pair list elements
type PropertyKeyValuePairList = [PropertyKeyValuePair]

_PropertyKeyValuePairList = Core.Name "openGql.grammar.PropertyKeyValuePairList"

-- | A GQL property name
type PropertyName = String

_PropertyName = Core.Name "openGql.grammar.PropertyName"

-- | A GQL property reference
data PropertyReference =
  PropertyReference {
    propertyReferenceValueExpression :: PrimaryValueExpression,
    propertyReferencePropertyName :: PropertyName}
  deriving (Eq, Ord, Read, Show)

_PropertyReference = Core.Name "openGql.grammar.PropertyReference"

_PropertyReference_valueExpression = Core.Name "valueExpression"

_PropertyReference_propertyName = Core.Name "propertyName"

-- | A GQL property type
data PropertyType =
  PropertyType {
    propertyTypeName :: PropertyName,
    propertyTypeTyped :: (Maybe Typed),
    propertyTypeValueType :: PropertyValueType}
  deriving (Eq, Ord, Read, Show)

_PropertyType = Core.Name "openGql.grammar.PropertyType"

_PropertyType_name = Core.Name "name"

_PropertyType_typed = Core.Name "typed"

_PropertyType_valueType = Core.Name "valueType"

-- | A list of GQL property type list elements
type PropertyTypeList = [PropertyType]

_PropertyTypeList = Core.Name "openGql.grammar.PropertyTypeList"

-- | An optional GQL property types specification
type PropertyTypesSpecification = (Maybe PropertyTypeList)

_PropertyTypesSpecification = Core.Name "openGql.grammar.PropertyTypesSpecification"

-- | A GQL property value type, equivalent to a value type
type PropertyValueType = ValueType

_PropertyValueType = Core.Name "openGql.grammar.PropertyValueType"

-- | A GQL quantified path primary
data QuantifiedPathPrimary =
  QuantifiedPathPrimary {
    quantifiedPathPrimaryPrimary :: PathPrimary,
    quantifiedPathPrimaryQuantifier :: GraphPatternQuantifier}
  deriving (Eq, Ord, Read, Show)

_QuantifiedPathPrimary = Core.Name "openGql.grammar.QuantifiedPathPrimary"

_QuantifiedPathPrimary_primary = Core.Name "primary"

_QuantifiedPathPrimary_quantifier = Core.Name "quantifier"

-- | A GQL query conjunction: one of several alternative forms
data QueryConjunction =
  QueryConjunctionSetOperator SetOperator |
  QueryConjunctionOtherwise
  deriving (Eq, Ord, Read, Show)

_QueryConjunction = Core.Name "openGql.grammar.QueryConjunction"

_QueryConjunction_setOperator = Core.Name "setOperator"

_QueryConjunction_otherwise = Core.Name "otherwise"

-- | A GQL questioned path primary, equivalent to a path primary
type QuestionedPathPrimary = PathPrimary

_QuestionedPathPrimary = Core.Name "openGql.grammar.QuestionedPathPrimary"

-- | A GQL real type
data RealType =
  RealType {
    realTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_RealType = Core.Name "openGql.grammar.RealType"

_RealType_notNull = Core.Name "notNull"

-- | A GQL record constructor, equivalent to a fields specification
type RecordConstructor = FieldsSpecification

_RecordConstructor = Core.Name "openGql.grammar.RecordConstructor"

-- | A GQL record literal, equivalent to a record constructor
type RecordLiteral = RecordConstructor

_RecordLiteral = Core.Name "openGql.grammar.RecordLiteral"

-- | A GQL record type: one of several alternative forms
data RecordType =
  RecordTypeAnyRecord AnyRecordType |
  RecordTypeSpecifiedRecord SpecifiedRecordType
  deriving (Eq, Ord, Read, Show)

_RecordType = Core.Name "openGql.grammar.RecordType"

_RecordType_anyRecord = Core.Name "anyRecord"

_RecordType_specifiedRecord = Core.Name "specifiedRecord"

-- | A GQL reference parameter specification
type ReferenceParameterSpecification = ()

_ReferenceParameterSpecification = Core.Name "openGql.grammar.ReferenceParameterSpecification"

-- | A GQL reference value type: one of several alternative forms
data ReferenceValueType =
  ReferenceValueTypeGraph GraphReferenceValueType |
  ReferenceValueTypeBindingTable BindingTableReferenceValueType |
  ReferenceValueTypeNode NodeReferenceValueType |
  ReferenceValueTypeEdge EdgeReferenceValueType
  deriving (Eq, Ord, Read, Show)

_ReferenceValueType = Core.Name "openGql.grammar.ReferenceValueType"

_ReferenceValueType_graph = Core.Name "graph"

_ReferenceValueType_bindingTable = Core.Name "bindingTable"

_ReferenceValueType_node = Core.Name "node"

_ReferenceValueType_edge = Core.Name "edge"

-- | A GQL regular identifier
type RegularIdentifier = String

_RegularIdentifier = Core.Name "openGql.grammar.RegularIdentifier"

-- | A GQL relative catalog schema reference: one of several alternative forms
data RelativeCatalogSchemaReference =
  RelativeCatalogSchemaReferencePredefinedReference PredefinedSchemaReference |
  RelativeCatalogSchemaReferenceDirectoryAndSchema RelativeDirectoryAndSchema
  deriving (Eq, Ord, Read, Show)

_RelativeCatalogSchemaReference = Core.Name "openGql.grammar.RelativeCatalogSchemaReference"

_RelativeCatalogSchemaReference_predefinedReference = Core.Name "predefinedReference"

_RelativeCatalogSchemaReference_directoryAndSchema = Core.Name "directoryAndSchema"

-- | A GQL relative directory and schema
data RelativeDirectoryAndSchema =
  RelativeDirectoryAndSchema {
    relativeDirectoryAndSchemaDirectoryPath :: RelativeDirectoryPath,
    relativeDirectoryAndSchemaSchemaName :: SchemaName}
  deriving (Eq, Ord, Read, Show)

_RelativeDirectoryAndSchema = Core.Name "openGql.grammar.RelativeDirectoryAndSchema"

_RelativeDirectoryAndSchema_directoryPath = Core.Name "directoryPath"

_RelativeDirectoryAndSchema_schemaName = Core.Name "schemaName"

-- | A GQL relative directory path
data RelativeDirectoryPath =
  RelativeDirectoryPath {
    relativeDirectoryPathParentDirectories :: Int,
    relativeDirectoryPathSimplePath :: (Maybe SimpleDirectoryPath)}
  deriving (Eq, Ord, Read, Show)

_RelativeDirectoryPath = Core.Name "openGql.grammar.RelativeDirectoryPath"

_RelativeDirectoryPath_parentDirectories = Core.Name "parentDirectories"

_RelativeDirectoryPath_simplePath = Core.Name "simplePath"

-- | A GQL remove item: one of several alternative forms
data RemoveItem =
  RemoveItemProperty RemovePropertyItem |
  RemoveItemLabel RemoveLabelItem
  deriving (Eq, Ord, Read, Show)

_RemoveItem = Core.Name "openGql.grammar.RemoveItem"

_RemoveItem_property = Core.Name "property"

_RemoveItem_label = Core.Name "label"

-- | A list of GQL remove item list elements
type RemoveItemList = [RemoveItem]

_RemoveItemList = Core.Name "openGql.grammar.RemoveItemList"

-- | A GQL remove label item
data RemoveLabelItem =
  RemoveLabelItem {
    removeLabelItemVariable :: BindingVariableReference,
    removeLabelItemIsOrColon :: IsOrColon,
    removeLabelItemLabel :: LabelName}
  deriving (Eq, Ord, Read, Show)

_RemoveLabelItem = Core.Name "openGql.grammar.RemoveLabelItem"

_RemoveLabelItem_variable = Core.Name "variable"

_RemoveLabelItem_isOrColon = Core.Name "isOrColon"

_RemoveLabelItem_label = Core.Name "label"

-- | A GQL remove property item
data RemovePropertyItem =
  RemovePropertyItem {
    removePropertyItemVariable :: BindingVariableReference,
    removePropertyItemPropertyName :: PropertyName}
  deriving (Eq, Ord, Read, Show)

_RemovePropertyItem = Core.Name "openGql.grammar.RemovePropertyItem"

_RemovePropertyItem_variable = Core.Name "variable"

_RemovePropertyItem_propertyName = Core.Name "propertyName"

-- | A GQL remove statement, equivalent to a remove item list
type RemoveStatement = RemoveItemList

_RemoveStatement = Core.Name "openGql.grammar.RemoveStatement"

-- | A GQL repeatable elements match mode, equivalent to a element bindings or elements
type RepeatableElementsMatchMode = ElementBindingsOrElements

_RepeatableElementsMatchMode = Core.Name "openGql.grammar.RepeatableElementsMatchMode"

-- | A GQL result: one of several alternative forms
data Result =
  ResultSimple ResultExpression |
  ResultNullLiteral
  deriving (Eq, Ord, Read, Show)

_Result = Core.Name "openGql.grammar.Result"

_Result_simple = Core.Name "simple"

_Result_nullLiteral = Core.Name "nullLiteral"

-- | A GQL result expression, equivalent to a value expression
type ResultExpression = ValueExpression

_ResultExpression = Core.Name "openGql.grammar.ResultExpression"

-- | A GQL return and optional order by and page
data ReturnAndOptionalOrderByAndPage =
  ReturnAndOptionalOrderByAndPage {
    returnAndOptionalOrderByAndPageReturn :: ReturnStatement,
    returnAndOptionalOrderByAndPageOrderByAndPage :: (Maybe OrderByAndPageStatement)}
  deriving (Eq, Ord, Read, Show)

_ReturnAndOptionalOrderByAndPage = Core.Name "openGql.grammar.ReturnAndOptionalOrderByAndPage"

_ReturnAndOptionalOrderByAndPage_return = Core.Name "return"

_ReturnAndOptionalOrderByAndPage_orderByAndPage = Core.Name "orderByAndPage"

-- | A GQL return item
data ReturnItem =
  ReturnItem {
    returnItemExpression :: AggregatingValueExpression,
    returnItemAlias :: (Maybe ReturnItemAlias)}
  deriving (Eq, Ord, Read, Show)

_ReturnItem = Core.Name "openGql.grammar.ReturnItem"

_ReturnItem_expression = Core.Name "expression"

_ReturnItem_alias = Core.Name "alias"

-- | A GQL return item alias
type ReturnItemAlias = String

_ReturnItemAlias = Core.Name "openGql.grammar.ReturnItemAlias"

-- | A list of GQL return item list elements
type ReturnItemList = [ReturnItem]

_ReturnItemList = Core.Name "openGql.grammar.ReturnItemList"

-- | A GQL return items: one of several alternative forms
data ReturnItems =
  ReturnItemsAsterisk |
  ReturnItemsItemList ReturnItemList
  deriving (Eq, Ord, Read, Show)

_ReturnItems = Core.Name "openGql.grammar.ReturnItems"

_ReturnItems_asterisk = Core.Name "asterisk"

_ReturnItems_itemList = Core.Name "itemList"

-- | A GQL return items and group by
data ReturnItemsAndGroupBy =
  ReturnItemsAndGroupBy {
    returnItemsAndGroupByQuantifier :: (Maybe SetQuantifier),
    returnItemsAndGroupByItems :: ReturnItems,
    returnItemsAndGroupByGroupBy :: (Maybe GroupByClause)}
  deriving (Eq, Ord, Read, Show)

_ReturnItemsAndGroupBy = Core.Name "openGql.grammar.ReturnItemsAndGroupBy"

_ReturnItemsAndGroupBy_quantifier = Core.Name "quantifier"

_ReturnItemsAndGroupBy_items = Core.Name "items"

_ReturnItemsAndGroupBy_groupBy = Core.Name "groupBy"

-- | A GQL return statement, equivalent to a return statement body
type ReturnStatement = ReturnStatementBody

_ReturnStatement = Core.Name "openGql.grammar.ReturnStatement"

-- | A GQL return statement body: one of several alternative forms
data ReturnStatementBody =
  ReturnStatementBodyItems ReturnItemsAndGroupBy |
  ReturnStatementBodyNoBindings
  deriving (Eq, Ord, Read, Show)

_ReturnStatementBody = Core.Name "openGql.grammar.ReturnStatementBody"

_ReturnStatementBody_items = Core.Name "items"

_ReturnStatementBody_noBindings = Core.Name "noBindings"

-- | A GQL rollback command
type RollbackCommand = ()

_RollbackCommand = Core.Name "openGql.grammar.RollbackCommand"

-- | A GQL same predicate
data SamePredicate =
  SamePredicate {
    samePredicateReferences :: [ElementVariableReference]}
  deriving (Eq, Ord, Read, Show)

_SamePredicate = Core.Name "openGql.grammar.SamePredicate"

_SamePredicate_references = Core.Name "references"

-- | A GQL scale, equivalent to a unsigned decimal integer
type Scale = UnsignedDecimalInteger

_Scale = Core.Name "openGql.grammar.Scale"

-- | A GQL schema and objects
data SchemaAndObjects =
  SchemaAndObjects {
    schemaAndObjectsSchemaReference :: SchemaReference,
    schemaAndObjectsObjects :: [ObjectName]}
  deriving (Eq, Ord, Read, Show)

_SchemaAndObjects = Core.Name "openGql.grammar.SchemaAndObjects"

_SchemaAndObjects_schemaReference = Core.Name "schemaReference"

_SchemaAndObjects_objects = Core.Name "objects"

-- | A GQL schema name
type SchemaName = String

_SchemaName = Core.Name "openGql.grammar.SchemaName"

-- | A GQL schema reference: one of several alternative forms
data SchemaReference =
  SchemaReferenceAbsoluteReference AbsoluteCatalogSchemaReference |
  SchemaReferenceRelativeReference RelativeCatalogSchemaReference |
  SchemaReferenceParameterSpecification ReferenceParameterSpecification
  deriving (Eq, Ord, Read, Show)

_SchemaReference = Core.Name "openGql.grammar.SchemaReference"

_SchemaReference_absoluteReference = Core.Name "absoluteReference"

_SchemaReference_relativeReference = Core.Name "relativeReference"

_SchemaReference_parameterSpecification = Core.Name "parameterSpecification"

-- | A GQL search condition, equivalent to a boolean value expression
type SearchCondition = BooleanValueExpression

_SearchCondition = Core.Name "openGql.grammar.SearchCondition"

-- | A GQL searched case
data SearchedCase =
  SearchedCase {
    searchedCaseWhenClauses :: [SearchedWhenClause],
    searchedCaseElseClause :: (Maybe ElseClause)}
  deriving (Eq, Ord, Read, Show)

_SearchedCase = Core.Name "openGql.grammar.SearchedCase"

_SearchedCase_whenClauses = Core.Name "whenClauses"

_SearchedCase_elseClause = Core.Name "elseClause"

-- | A GQL searched when clause
data SearchedWhenClause =
  SearchedWhenClause {
    searchedWhenClauseSearchCondition :: SearchCondition,
    searchedWhenClauseResult :: Result}
  deriving (Eq, Ord, Read, Show)

_SearchedWhenClause = Core.Name "openGql.grammar.SearchedWhenClause"

_SearchedWhenClause_searchCondition = Core.Name "searchCondition"

_SearchedWhenClause_result = Core.Name "result"

-- | A GQL select graph match
data SelectGraphMatch =
  SelectGraphMatch {
    selectGraphMatchGraphExpression :: GraphExpression,
    selectGraphMatchMatchStatement :: MatchStatement}
  deriving (Eq, Ord, Read, Show)

_SelectGraphMatch = Core.Name "openGql.grammar.SelectGraphMatch"

_SelectGraphMatch_graphExpression = Core.Name "graphExpression"

_SelectGraphMatch_matchStatement = Core.Name "matchStatement"

-- | A list of GQL select graph match list elements
type SelectGraphMatchList = [SelectGraphMatch]

_SelectGraphMatchList = Core.Name "openGql.grammar.SelectGraphMatchList"

-- | A GQL select item
data SelectItem =
  SelectItem {
    selectItemExpression :: AggregatingValueExpression,
    selectItemAlias :: (Maybe SelectItemAlias)}
  deriving (Eq, Ord, Read, Show)

_SelectItem = Core.Name "openGql.grammar.SelectItem"

_SelectItem_expression = Core.Name "expression"

_SelectItem_alias = Core.Name "alias"

-- | A GQL select item alias
type SelectItemAlias = String

_SelectItemAlias = Core.Name "openGql.grammar.SelectItemAlias"

-- | A list of GQL select item list elements
type SelectItemList = [SelectItem]

_SelectItemList = Core.Name "openGql.grammar.SelectItemList"

-- | A GQL select items: one of several alternative forms
data SelectItems =
  SelectItemsAsterisk |
  SelectItemsItemList SelectItemList
  deriving (Eq, Ord, Read, Show)

_SelectItems = Core.Name "openGql.grammar.SelectItems"

_SelectItems_asterisk = Core.Name "asterisk"

_SelectItems_itemList = Core.Name "itemList"

-- | A GQL select query specification: one of several alternative forms
data SelectQuerySpecification =
  SelectQuerySpecificationNested NestedQuerySpecification |
  SelectQuerySpecificationGraphAndNested GraphAndNestedQuerySpecification
  deriving (Eq, Ord, Read, Show)

_SelectQuerySpecification = Core.Name "openGql.grammar.SelectQuerySpecification"

_SelectQuerySpecification_nested = Core.Name "nested"

_SelectQuerySpecification_graphAndNested = Core.Name "graphAndNested"

-- | A GQL select statement
data SelectStatement =
  SelectStatement {
    selectStatementQuantifier :: (Maybe SetQuantifier),
    selectStatementItems :: SelectItems,
    selectStatementBody :: (Maybe SelectStatementBodyAndClauses)}
  deriving (Eq, Ord, Read, Show)

_SelectStatement = Core.Name "openGql.grammar.SelectStatement"

_SelectStatement_quantifier = Core.Name "quantifier"

_SelectStatement_items = Core.Name "items"

_SelectStatement_body = Core.Name "body"

-- | A GQL select statement body: one of several alternative forms
data SelectStatementBody =
  SelectStatementBodyGraphMatchList SelectGraphMatchList |
  SelectStatementBodyQuerySpecification SelectQuerySpecification
  deriving (Eq, Ord, Read, Show)

_SelectStatementBody = Core.Name "openGql.grammar.SelectStatementBody"

_SelectStatementBody_graphMatchList = Core.Name "graphMatchList"

_SelectStatementBody_querySpecification = Core.Name "querySpecification"

-- | A GQL select statement body and clauses
data SelectStatementBodyAndClauses =
  SelectStatementBodyAndClauses {
    selectStatementBodyAndClausesBody :: SelectStatementBody,
    selectStatementBodyAndClausesWhere :: (Maybe WhereClause),
    selectStatementBodyAndClausesGroupBy :: (Maybe GroupByClause),
    selectStatementBodyAndClausesHaving :: (Maybe HavingClause),
    selectStatementBodyAndClausesOrderBy :: (Maybe OrderByClause),
    selectStatementBodyAndClausesOffset :: (Maybe OffsetClause),
    selectStatementBodyAndClausesLimit :: (Maybe LimitClause)}
  deriving (Eq, Ord, Read, Show)

_SelectStatementBodyAndClauses = Core.Name "openGql.grammar.SelectStatementBodyAndClauses"

_SelectStatementBodyAndClauses_body = Core.Name "body"

_SelectStatementBodyAndClauses_where = Core.Name "where"

_SelectStatementBodyAndClauses_groupBy = Core.Name "groupBy"

_SelectStatementBodyAndClauses_having = Core.Name "having"

_SelectStatementBodyAndClauses_orderBy = Core.Name "orderBy"

_SelectStatementBodyAndClauses_offset = Core.Name "offset"

_SelectStatementBodyAndClauses_limit = Core.Name "limit"

-- | A GQL session activity: one of several alternative forms
data SessionActivity =
  SessionActivityReset [SessionResetCommand] |
  SessionActivitySetAndResetCommands SessionSetAndResetCommands
  deriving (Eq, Ord, Read, Show)

_SessionActivity = Core.Name "openGql.grammar.SessionActivity"

_SessionActivity_reset = Core.Name "reset"

_SessionActivity_setAndResetCommands = Core.Name "setAndResetCommands"

-- | A GQL session close command
type SessionCloseCommand = ()

_SessionCloseCommand = Core.Name "openGql.grammar.SessionCloseCommand"

-- | A GQL session parameter specification, equivalent to a parameter name
type SessionParameterSpecification = ParameterName

_SessionParameterSpecification = Core.Name "openGql.grammar.SessionParameterSpecification"

-- | A GQL session reset arguments: one of several alternative forms
data SessionResetArguments =
  SessionResetArgumentsParametersOrCharacteristics AllParametersOrCharacteristics |
  SessionResetArgumentsSchema |
  SessionResetArgumentsGraph |
  SessionResetArgumentsTimeZone |
  SessionResetArgumentsParameterSessionSpecification ParameterSessionSpecification
  deriving (Eq, Ord, Read, Show)

_SessionResetArguments = Core.Name "openGql.grammar.SessionResetArguments"

_SessionResetArguments_parametersOrCharacteristics = Core.Name "parametersOrCharacteristics"

_SessionResetArguments_schema = Core.Name "schema"

_SessionResetArguments_graph = Core.Name "graph"

_SessionResetArguments_timeZone = Core.Name "timeZone"

_SessionResetArguments_parameterSessionSpecification = Core.Name "parameterSessionSpecification"

-- | An optional GQL session reset command
type SessionResetCommand = (Maybe SessionResetArguments)

_SessionResetCommand = Core.Name "openGql.grammar.SessionResetCommand"

-- | A GQL session set and reset commands
data SessionSetAndResetCommands =
  SessionSetAndResetCommands {
    sessionSetAndResetCommandsSet :: [SessionSetCommand],
    sessionSetAndResetCommandsReset :: [SessionResetCommand]}
  deriving (Eq, Ord, Read, Show)

_SessionSetAndResetCommands = Core.Name "openGql.grammar.SessionSetAndResetCommands"

_SessionSetAndResetCommands_set = Core.Name "set"

_SessionSetAndResetCommands_reset = Core.Name "reset"

-- | A GQL session set binding table parameter clause
data SessionSetBindingTableParameterClause =
  SessionSetBindingTableParameterClause {
    sessionSetBindingTableParameterClauseBinding :: Bool,
    sessionSetBindingTableParameterClauseParam :: SessionSetParameterName,
    sessionSetBindingTableParameterClauseInit :: OptTypedBindingTableInitializer}
  deriving (Eq, Ord, Read, Show)

_SessionSetBindingTableParameterClause = Core.Name "openGql.grammar.SessionSetBindingTableParameterClause"

_SessionSetBindingTableParameterClause_binding = Core.Name "binding"

_SessionSetBindingTableParameterClause_param = Core.Name "param"

_SessionSetBindingTableParameterClause_init = Core.Name "init"

-- | A GQL session set command: one of several alternative forms
data SessionSetCommand =
  SessionSetCommandSchema SessionSetSchemaClause |
  SessionSetCommandGraph SessionSetGraphClause |
  SessionSetCommandTimeZone SessionSetTimeZoneClause |
  SessionSetCommandParameter SessionSetParameterClause
  deriving (Eq, Ord, Read, Show)

_SessionSetCommand = Core.Name "openGql.grammar.SessionSetCommand"

_SessionSetCommand_schema = Core.Name "schema"

_SessionSetCommand_graph = Core.Name "graph"

_SessionSetCommand_timeZone = Core.Name "timeZone"

_SessionSetCommand_parameter = Core.Name "parameter"

-- | A GQL session set graph clause, equivalent to a graph expression
type SessionSetGraphClause = GraphExpression

_SessionSetGraphClause = Core.Name "openGql.grammar.SessionSetGraphClause"

-- | A GQL session set graph parameter clause
data SessionSetGraphParameterClause =
  SessionSetGraphParameterClause {
    sessionSetGraphParameterClauseGraph :: SessionSetParameterName,
    sessionSetGraphParameterClauseInitializer :: OptTypedGraphInitializer}
  deriving (Eq, Ord, Read, Show)

_SessionSetGraphParameterClause = Core.Name "openGql.grammar.SessionSetGraphParameterClause"

_SessionSetGraphParameterClause_graph = Core.Name "graph"

_SessionSetGraphParameterClause_initializer = Core.Name "initializer"

-- | A GQL session set parameter clause: one of several alternative forms
data SessionSetParameterClause =
  SessionSetParameterClauseGraph SessionSetGraphParameterClause |
  SessionSetParameterClauseBindings SessionSetBindingTableParameterClause |
  SessionSetParameterClauseValue SessionSetValueParameterClause
  deriving (Eq, Ord, Read, Show)

_SessionSetParameterClause = Core.Name "openGql.grammar.SessionSetParameterClause"

_SessionSetParameterClause_graph = Core.Name "graph"

_SessionSetParameterClause_bindings = Core.Name "bindings"

_SessionSetParameterClause_value = Core.Name "value"

-- | A GQL session set parameter name
data SessionSetParameterName =
  SessionSetParameterName {
    sessionSetParameterNameIfNotExists :: Bool,
    sessionSetParameterNameParameter :: SessionParameterSpecification}
  deriving (Eq, Ord, Read, Show)

_SessionSetParameterName = Core.Name "openGql.grammar.SessionSetParameterName"

_SessionSetParameterName_ifNotExists = Core.Name "ifNotExists"

_SessionSetParameterName_parameter = Core.Name "parameter"

-- | A GQL session set schema clause, equivalent to a schema reference
type SessionSetSchemaClause = SchemaReference

_SessionSetSchemaClause = Core.Name "openGql.grammar.SessionSetSchemaClause"

-- | A GQL session set time zone clause, equivalent to a set time zone value
type SessionSetTimeZoneClause = SetTimeZoneValue

_SessionSetTimeZoneClause = Core.Name "openGql.grammar.SessionSetTimeZoneClause"

-- | A GQL session set value parameter clause
data SessionSetValueParameterClause =
  SessionSetValueParameterClause {
    sessionSetValueParameterClauseValue :: SessionSetParameterName,
    sessionSetValueParameterClauseInitializer :: OptTypedValueInitializer}
  deriving (Eq, Ord, Read, Show)

_SessionSetValueParameterClause = Core.Name "openGql.grammar.SessionSetValueParameterClause"

_SessionSetValueParameterClause_value = Core.Name "value"

_SessionSetValueParameterClause_initializer = Core.Name "initializer"

-- | A GQL set all properties item
data SetAllPropertiesItem =
  SetAllPropertiesItem {
    setAllPropertiesItemVariable :: BindingVariableReference,
    setAllPropertiesItemProperties :: (Maybe PropertyKeyValuePairList)}
  deriving (Eq, Ord, Read, Show)

_SetAllPropertiesItem = Core.Name "openGql.grammar.SetAllPropertiesItem"

_SetAllPropertiesItem_variable = Core.Name "variable"

_SetAllPropertiesItem_properties = Core.Name "properties"

-- | A GQL set item: one of several alternative forms
data SetItem =
  SetItemProperty SetPropertyItem |
  SetItemAllProperties SetAllPropertiesItem |
  SetItemLabel SetLabelItem
  deriving (Eq, Ord, Read, Show)

_SetItem = Core.Name "openGql.grammar.SetItem"

_SetItem_property = Core.Name "property"

_SetItem_allProperties = Core.Name "allProperties"

_SetItem_label = Core.Name "label"

-- | A list of GQL set item list elements
type SetItemList = [SetItem]

_SetItemList = Core.Name "openGql.grammar.SetItemList"

-- | A GQL set label item
data SetLabelItem =
  SetLabelItem {
    setLabelItemVariable :: BindingVariableReference,
    setLabelItemIsOrColon :: IsOrColon,
    setLabelItemLabel :: LabelName}
  deriving (Eq, Ord, Read, Show)

_SetLabelItem = Core.Name "openGql.grammar.SetLabelItem"

_SetLabelItem_variable = Core.Name "variable"

_SetLabelItem_isOrColon = Core.Name "isOrColon"

_SetLabelItem_label = Core.Name "label"

-- | A GQL set operator
data SetOperator =
  SetOperator {
    setOperatorOperatorType :: SetOperatorType,
    setOperatorQuantifier :: (Maybe SetQuantifier)}
  deriving (Eq, Ord, Read, Show)

_SetOperator = Core.Name "openGql.grammar.SetOperator"

_SetOperator_operatorType = Core.Name "operatorType"

_SetOperator_quantifier = Core.Name "quantifier"

-- | A GQL set operator type: one of a fixed set of alternatives
data SetOperatorType =
  SetOperatorTypeUnion |
  SetOperatorTypeExcept |
  SetOperatorTypeIntersect
  deriving (Eq, Ord, Read, Show)

_SetOperatorType = Core.Name "openGql.grammar.SetOperatorType"

_SetOperatorType_union = Core.Name "union"

_SetOperatorType_except = Core.Name "except"

_SetOperatorType_intersect = Core.Name "intersect"

-- | A GQL set property item
data SetPropertyItem =
  SetPropertyItem {
    setPropertyItemVariable :: BindingVariableReference,
    setPropertyItemPropertyName :: PropertyName,
    setPropertyItemValue :: ValueExpression}
  deriving (Eq, Ord, Read, Show)

_SetPropertyItem = Core.Name "openGql.grammar.SetPropertyItem"

_SetPropertyItem_variable = Core.Name "variable"

_SetPropertyItem_propertyName = Core.Name "propertyName"

_SetPropertyItem_value = Core.Name "value"

-- | A GQL set quantifier: one of a fixed set of alternatives
data SetQuantifier =
  SetQuantifierDistinct |
  SetQuantifierAll
  deriving (Eq, Ord, Read, Show)

_SetQuantifier = Core.Name "openGql.grammar.SetQuantifier"

_SetQuantifier_distinct = Core.Name "distinct"

_SetQuantifier_all = Core.Name "all"

-- | A GQL set statement, equivalent to a set item list
type SetStatement = SetItemList

_SetStatement = Core.Name "openGql.grammar.SetStatement"

-- | A GQL set time zone value, equivalent to a time zone string
type SetTimeZoneValue = TimeZoneString

_SetTimeZoneValue = Core.Name "openGql.grammar.SetTimeZoneValue"

-- | A GQL shortest path search: one of several alternative forms
data ShortestPathSearch =
  ShortestPathSearchAllShortest AllShortestPathSearch |
  ShortestPathSearchAnyShortest AnyShortestPathSearch |
  ShortestPathSearchCountedShortest CountedShortestPathSearch |
  ShortestPathSearchCountedShortestGroup CountedShortestGroupSearch
  deriving (Eq, Ord, Read, Show)

_ShortestPathSearch = Core.Name "openGql.grammar.ShortestPathSearch"

_ShortestPathSearch_allShortest = Core.Name "allShortest"

_ShortestPathSearch_anyShortest = Core.Name "anyShortest"

_ShortestPathSearch_countedShortest = Core.Name "countedShortest"

_ShortestPathSearch_countedShortestGroup = Core.Name "countedShortestGroup"

-- | A GQL side: one of a fixed set of alternatives
data Side =
  SideLeft |
  SideRight
  deriving (Eq, Ord, Read, Show)

_Side = Core.Name "openGql.grammar.Side"

_Side_left = Core.Name "left"

_Side_right = Core.Name "right"

-- | A GQL sign: one of a fixed set of alternatives
data Sign =
  SignPlus |
  SignMinus
  deriving (Eq, Ord, Read, Show)

_Sign = Core.Name "openGql.grammar.Sign"

_Sign_plus = Core.Name "plus"

_Sign_minus = Core.Name "minus"

-- | A GQL signed binary exact numeric type: one of several alternative forms
data SignedBinaryExactNumericType =
  SignedBinaryExactNumericTypeInt8 Int8Type |
  SignedBinaryExactNumericTypeInt16 Int16Type |
  SignedBinaryExactNumericTypeInt32 Int32Type |
  SignedBinaryExactNumericTypeInt64 Int64Type |
  SignedBinaryExactNumericTypeInt128 Int128Type |
  SignedBinaryExactNumericTypeInt256 Int256Type |
  SignedBinaryExactNumericTypeSmallInt SmallIntType |
  SignedBinaryExactNumericTypeIntWithPrecision IntWithPrecision |
  SignedBinaryExactNumericTypeBigInt BigIntType |
  SignedBinaryExactNumericTypeSignedVerboseType SignedVerboseBinaryExactNumericType
  deriving (Eq, Ord, Read, Show)

_SignedBinaryExactNumericType = Core.Name "openGql.grammar.SignedBinaryExactNumericType"

_SignedBinaryExactNumericType_int8 = Core.Name "int8"

_SignedBinaryExactNumericType_int16 = Core.Name "int16"

_SignedBinaryExactNumericType_int32 = Core.Name "int32"

_SignedBinaryExactNumericType_int64 = Core.Name "int64"

_SignedBinaryExactNumericType_int128 = Core.Name "int128"

_SignedBinaryExactNumericType_int256 = Core.Name "int256"

_SignedBinaryExactNumericType_smallInt = Core.Name "smallInt"

_SignedBinaryExactNumericType_intWithPrecision = Core.Name "intWithPrecision"

_SignedBinaryExactNumericType_bigInt = Core.Name "bigInt"

_SignedBinaryExactNumericType_signedVerboseType = Core.Name "signedVerboseType"

-- | A GQL signed expression
data SignedExpr =
  SignedExpr {
    signedExprSign :: Sign,
    signedExprValueExpression :: ValueExpression}
  deriving (Eq, Ord, Read, Show)

_SignedExpr = Core.Name "openGql.grammar.SignedExpr"

_SignedExpr_sign = Core.Name "sign"

_SignedExpr_valueExpression = Core.Name "valueExpression"

-- | A GQL signed numeric value expression
data SignedNumericValueExpression =
  SignedNumericValueExpression {
    signedNumericValueExpressionSign :: Sign,
    signedNumericValueExpressionExpression :: NumericValueExpression}
  deriving (Eq, Ord, Read, Show)

_SignedNumericValueExpression = Core.Name "openGql.grammar.SignedNumericValueExpression"

_SignedNumericValueExpression_sign = Core.Name "sign"

_SignedNumericValueExpression_expression = Core.Name "expression"

-- | A GQL signed verbose binary exact numeric type
data SignedVerboseBinaryExactNumericType =
  SignedVerboseBinaryExactNumericType {
    signedVerboseBinaryExactNumericTypeSigned :: Bool,
    signedVerboseBinaryExactNumericTypeVerboseType :: VerboseBinaryExactNumericType}
  deriving (Eq, Ord, Read, Show)

_SignedVerboseBinaryExactNumericType = Core.Name "openGql.grammar.SignedVerboseBinaryExactNumericType"

_SignedVerboseBinaryExactNumericType_signed = Core.Name "signed"

_SignedVerboseBinaryExactNumericType_verboseType = Core.Name "verboseType"

-- | A GQL simple case
data SimpleCase =
  SimpleCase {
    simpleCaseCaseOperand :: CaseOperand,
    simpleCaseWhenClauses :: [SimpleWhenClause],
    simpleCaseElseClause :: (Maybe ElseClause)}
  deriving (Eq, Ord, Read, Show)

_SimpleCase = Core.Name "openGql.grammar.SimpleCase"

_SimpleCase_caseOperand = Core.Name "caseOperand"

_SimpleCase_whenClauses = Core.Name "whenClauses"

_SimpleCase_elseClause = Core.Name "elseClause"

-- | A GQL simple catalog modifying statement: one of several alternative forms
data SimpleCatalogModifyingStatement =
  SimpleCatalogModifyingStatementPrimitive PrimitiveCatalogModifyingStatement |
  SimpleCatalogModifyingStatementCallProcedure CallCatalogModifyingProcedureStatement
  deriving (Eq, Ord, Read, Show)

_SimpleCatalogModifyingStatement = Core.Name "openGql.grammar.SimpleCatalogModifyingStatement"

_SimpleCatalogModifyingStatement_primitive = Core.Name "primitive"

_SimpleCatalogModifyingStatement_callProcedure = Core.Name "callProcedure"

-- | A GQL simple data accessing statement: one of several alternative forms
data SimpleDataAccessingStatement =
  SimpleDataAccessingStatementQuery SimpleQueryStatement |
  SimpleDataAccessingStatementModifying SimpleDataModifyingStatement
  deriving (Eq, Ord, Read, Show)

_SimpleDataAccessingStatement = Core.Name "openGql.grammar.SimpleDataAccessingStatement"

_SimpleDataAccessingStatement_query = Core.Name "query"

_SimpleDataAccessingStatement_modifying = Core.Name "modifying"

-- | A GQL simple data modifying statement: one of several alternative forms
data SimpleDataModifyingStatement =
  SimpleDataModifyingStatementPrimitive PrimitiveDataModifyingStatement |
  SimpleDataModifyingStatementCallProcedure CallDataModifyingProcedureStatement
  deriving (Eq, Ord, Read, Show)

_SimpleDataModifyingStatement = Core.Name "openGql.grammar.SimpleDataModifyingStatement"

_SimpleDataModifyingStatement_primitive = Core.Name "primitive"

_SimpleDataModifyingStatement_callProcedure = Core.Name "callProcedure"

-- | A list of GQL simple directory path elements
type SimpleDirectoryPath = [DirectoryName]

_SimpleDirectoryPath = Core.Name "openGql.grammar.SimpleDirectoryPath"

-- | A list of GQL simple linear data accessing statement elements
type SimpleLinearDataAccessingStatement = [SimpleDataAccessingStatement]

_SimpleLinearDataAccessingStatement = Core.Name "openGql.grammar.SimpleLinearDataAccessingStatement"

-- | A list of GQL simple linear query statement elements
type SimpleLinearQueryStatement = [SimpleQueryStatement]

_SimpleLinearQueryStatement = Core.Name "openGql.grammar.SimpleLinearQueryStatement"

-- | A GQL simple match statement, equivalent to a graph pattern binding table
type SimpleMatchStatement = GraphPatternBindingTable

_SimpleMatchStatement = Core.Name "openGql.grammar.SimpleMatchStatement"

-- | A GQL simple query statement: one of several alternative forms
data SimpleQueryStatement =
  SimpleQueryStatementPrimitive PrimitiveQueryStatement |
  SimpleQueryStatementCall CallQueryStatement
  deriving (Eq, Ord, Read, Show)

_SimpleQueryStatement = Core.Name "openGql.grammar.SimpleQueryStatement"

_SimpleQueryStatement_primitive = Core.Name "primitive"

_SimpleQueryStatement_call = Core.Name "call"

-- | A GQL simple when clause
data SimpleWhenClause =
  SimpleWhenClause {
    simpleWhenClauseWhenOperands :: WhenOperandList,
    simpleWhenClauseResult :: Result}
  deriving (Eq, Ord, Read, Show)

_SimpleWhenClause = Core.Name "openGql.grammar.SimpleWhenClause"

_SimpleWhenClause_whenOperands = Core.Name "whenOperands"

_SimpleWhenClause_result = Core.Name "result"

-- | A GQL simplified concatenation
data SimplifiedConcatenation =
  SimplifiedConcatenation {
    simplifiedConcatenationInitialTerm :: SimplifiedTerm,
    simplifiedConcatenationNextFactor :: SimplifiedFactorLow}
  deriving (Eq, Ord, Read, Show)

_SimplifiedConcatenation = Core.Name "openGql.grammar.SimplifiedConcatenation"

_SimplifiedConcatenation_initialTerm = Core.Name "initialTerm"

_SimplifiedConcatenation_nextFactor = Core.Name "nextFactor"

-- | A GQL simplified conjunction
data SimplifiedConjunction =
  SimplifiedConjunction {
    simplifiedConjunctionLeft :: SimplifiedFactorLow,
    simplifiedConjunctionRight :: SimplifiedFactorHigh}
  deriving (Eq, Ord, Read, Show)

_SimplifiedConjunction = Core.Name "openGql.grammar.SimplifiedConjunction"

_SimplifiedConjunction_left = Core.Name "left"

_SimplifiedConjunction_right = Core.Name "right"

-- | A GQL simplified contents: one of several alternative forms
data SimplifiedContents =
  SimplifiedContentsTerm SimplifiedTerm |
  SimplifiedContentsPathUnion SimplifiedPathUnion |
  SimplifiedContentsMultisetAlternation SimplifiedMultisetAlternation
  deriving (Eq, Ord, Read, Show)

_SimplifiedContents = Core.Name "openGql.grammar.SimplifiedContents"

_SimplifiedContents_term = Core.Name "term"

_SimplifiedContents_pathUnion = Core.Name "pathUnion"

_SimplifiedContents_multisetAlternation = Core.Name "multisetAlternation"

-- | A GQL simplified defaulting any direction, equivalent to a simplified contents
type SimplifiedDefaultingAnyDirection = SimplifiedContents

_SimplifiedDefaultingAnyDirection = Core.Name "openGql.grammar.SimplifiedDefaultingAnyDirection"

-- | A GQL simplified defaulting left, equivalent to a simplified contents
type SimplifiedDefaultingLeft = SimplifiedContents

_SimplifiedDefaultingLeft = Core.Name "openGql.grammar.SimplifiedDefaultingLeft"

-- | A GQL simplified defaulting left or right, equivalent to a simplified contents
type SimplifiedDefaultingLeftOrRight = SimplifiedContents

_SimplifiedDefaultingLeftOrRight = Core.Name "openGql.grammar.SimplifiedDefaultingLeftOrRight"

-- | A GQL simplified defaulting left or undirected, equivalent to a simplified contents
type SimplifiedDefaultingLeftOrUndirected = SimplifiedContents

_SimplifiedDefaultingLeftOrUndirected = Core.Name "openGql.grammar.SimplifiedDefaultingLeftOrUndirected"

-- | A GQL simplified defaulting right, equivalent to a simplified contents
type SimplifiedDefaultingRight = SimplifiedContents

_SimplifiedDefaultingRight = Core.Name "openGql.grammar.SimplifiedDefaultingRight"

-- | A GQL simplified defaulting undirected, equivalent to a simplified contents
type SimplifiedDefaultingUndirected = SimplifiedContents

_SimplifiedDefaultingUndirected = Core.Name "openGql.grammar.SimplifiedDefaultingUndirected"

-- | A GQL simplified defaulting undirected or right, equivalent to a simplified contents
type SimplifiedDefaultingUndirectedOrRight = SimplifiedContents

_SimplifiedDefaultingUndirectedOrRight = Core.Name "openGql.grammar.SimplifiedDefaultingUndirectedOrRight"

-- | A GQL simplified direction override: one of several alternative forms
data SimplifiedDirectionOverride =
  SimplifiedDirectionOverrideOverrideLeft SimplifiedOverrideLeft |
  SimplifiedDirectionOverrideOverrideUndirected SimplifiedOverrideUndirected |
  SimplifiedDirectionOverrideOverrideRight SimplifiedOverrideRight |
  SimplifiedDirectionOverrideOverrideLeftOrUndirected SimplifiedOverrideLeftOrUndirected |
  SimplifiedDirectionOverrideOverrideUndirectedOrRight SimplifiedOverrideUndirectedOrRight |
  SimplifiedDirectionOverrideOverrideLeftOrRight SimplifiedOverrideLeftOrRight |
  SimplifiedDirectionOverrideOverrideAnyDirection SimplifiedOverrideAnyDirection
  deriving (Eq, Ord, Read, Show)

_SimplifiedDirectionOverride = Core.Name "openGql.grammar.SimplifiedDirectionOverride"

_SimplifiedDirectionOverride_overrideLeft = Core.Name "overrideLeft"

_SimplifiedDirectionOverride_overrideUndirected = Core.Name "overrideUndirected"

_SimplifiedDirectionOverride_overrideRight = Core.Name "overrideRight"

_SimplifiedDirectionOverride_overrideLeftOrUndirected = Core.Name "overrideLeftOrUndirected"

_SimplifiedDirectionOverride_overrideUndirectedOrRight = Core.Name "overrideUndirectedOrRight"

_SimplifiedDirectionOverride_overrideLeftOrRight = Core.Name "overrideLeftOrRight"

_SimplifiedDirectionOverride_overrideAnyDirection = Core.Name "overrideAnyDirection"

-- | A GQL simplified factor high: one of several alternative forms
data SimplifiedFactorHigh =
  SimplifiedFactorHighTertiary SimplifiedTertiary |
  SimplifiedFactorHighQuantified SimplifiedQuantified |
  SimplifiedFactorHighQuestioned SimplifiedQuestioned
  deriving (Eq, Ord, Read, Show)

_SimplifiedFactorHigh = Core.Name "openGql.grammar.SimplifiedFactorHigh"

_SimplifiedFactorHigh_tertiary = Core.Name "tertiary"

_SimplifiedFactorHigh_quantified = Core.Name "quantified"

_SimplifiedFactorHigh_questioned = Core.Name "questioned"

-- | A GQL simplified factor low: one of several alternative forms
data SimplifiedFactorLow =
  SimplifiedFactorLowFactorHigh SimplifiedFactorHigh |
  SimplifiedFactorLowConjunction SimplifiedConjunction
  deriving (Eq, Ord, Read, Show)

_SimplifiedFactorLow = Core.Name "openGql.grammar.SimplifiedFactorLow"

_SimplifiedFactorLow_factorHigh = Core.Name "factorHigh"

_SimplifiedFactorLow_conjunction = Core.Name "conjunction"

-- | A list of GQL simplified multiset alternation elements
type SimplifiedMultisetAlternation = [SimplifiedTerm]

_SimplifiedMultisetAlternation = Core.Name "openGql.grammar.SimplifiedMultisetAlternation"

-- | A GQL simplified negation, equivalent to a simplified primary
type SimplifiedNegation = SimplifiedPrimary

_SimplifiedNegation = Core.Name "openGql.grammar.SimplifiedNegation"

-- | A GQL simplified override any direction, equivalent to a simplified secondary
type SimplifiedOverrideAnyDirection = SimplifiedSecondary

_SimplifiedOverrideAnyDirection = Core.Name "openGql.grammar.SimplifiedOverrideAnyDirection"

-- | A GQL simplified override left, equivalent to a simplified secondary
type SimplifiedOverrideLeft = SimplifiedSecondary

_SimplifiedOverrideLeft = Core.Name "openGql.grammar.SimplifiedOverrideLeft"

-- | A GQL simplified override left or right, equivalent to a simplified secondary
type SimplifiedOverrideLeftOrRight = SimplifiedSecondary

_SimplifiedOverrideLeftOrRight = Core.Name "openGql.grammar.SimplifiedOverrideLeftOrRight"

-- | A GQL simplified override left or undirected, equivalent to a simplified secondary
type SimplifiedOverrideLeftOrUndirected = SimplifiedSecondary

_SimplifiedOverrideLeftOrUndirected = Core.Name "openGql.grammar.SimplifiedOverrideLeftOrUndirected"

-- | A GQL simplified override right, equivalent to a simplified secondary
type SimplifiedOverrideRight = SimplifiedSecondary

_SimplifiedOverrideRight = Core.Name "openGql.grammar.SimplifiedOverrideRight"

-- | A GQL simplified override undirected, equivalent to a simplified secondary
type SimplifiedOverrideUndirected = SimplifiedSecondary

_SimplifiedOverrideUndirected = Core.Name "openGql.grammar.SimplifiedOverrideUndirected"

-- | A GQL simplified override undirected or right, equivalent to a simplified secondary
type SimplifiedOverrideUndirectedOrRight = SimplifiedSecondary

_SimplifiedOverrideUndirectedOrRight = Core.Name "openGql.grammar.SimplifiedOverrideUndirectedOrRight"

-- | A GQL simplified path pattern expression: one of several alternative forms
data SimplifiedPathPatternExpression =
  SimplifiedPathPatternExpressionLeft SimplifiedDefaultingLeft |
  SimplifiedPathPatternExpressionUndirected SimplifiedDefaultingUndirected |
  SimplifiedPathPatternExpressionRight SimplifiedDefaultingRight |
  SimplifiedPathPatternExpressionLeftOrUndirected SimplifiedDefaultingLeftOrUndirected |
  SimplifiedPathPatternExpressionUndirectedOrRight SimplifiedDefaultingUndirectedOrRight |
  SimplifiedPathPatternExpressionLeftOrRight SimplifiedDefaultingLeftOrRight |
  SimplifiedPathPatternExpressionAnyDirection SimplifiedDefaultingAnyDirection
  deriving (Eq, Ord, Read, Show)

_SimplifiedPathPatternExpression = Core.Name "openGql.grammar.SimplifiedPathPatternExpression"

_SimplifiedPathPatternExpression_left = Core.Name "left"

_SimplifiedPathPatternExpression_undirected = Core.Name "undirected"

_SimplifiedPathPatternExpression_right = Core.Name "right"

_SimplifiedPathPatternExpression_leftOrUndirected = Core.Name "leftOrUndirected"

_SimplifiedPathPatternExpression_undirectedOrRight = Core.Name "undirectedOrRight"

_SimplifiedPathPatternExpression_leftOrRight = Core.Name "leftOrRight"

_SimplifiedPathPatternExpression_anyDirection = Core.Name "anyDirection"

-- | A list of GQL simplified path union elements
type SimplifiedPathUnion = [SimplifiedTerm]

_SimplifiedPathUnion = Core.Name "openGql.grammar.SimplifiedPathUnion"

-- | A GQL simplified primary: one of several alternative forms
data SimplifiedPrimary =
  SimplifiedPrimaryLabelName LabelName |
  SimplifiedPrimaryParenthesizedContents SimplifiedContents
  deriving (Eq, Ord, Read, Show)

_SimplifiedPrimary = Core.Name "openGql.grammar.SimplifiedPrimary"

_SimplifiedPrimary_labelName = Core.Name "labelName"

_SimplifiedPrimary_parenthesizedContents = Core.Name "parenthesizedContents"

-- | A GQL simplified quantified
data SimplifiedQuantified =
  SimplifiedQuantified {
    simplifiedQuantifiedTertiary :: SimplifiedTertiary,
    simplifiedQuantifiedQuantifier :: GraphPatternQuantifier}
  deriving (Eq, Ord, Read, Show)

_SimplifiedQuantified = Core.Name "openGql.grammar.SimplifiedQuantified"

_SimplifiedQuantified_tertiary = Core.Name "tertiary"

_SimplifiedQuantified_quantifier = Core.Name "quantifier"

-- | A GQL simplified questioned, equivalent to a simplified tertiary
type SimplifiedQuestioned = SimplifiedTertiary

_SimplifiedQuestioned = Core.Name "openGql.grammar.SimplifiedQuestioned"

-- | A GQL simplified secondary: one of several alternative forms
data SimplifiedSecondary =
  SimplifiedSecondaryPrimary SimplifiedPrimary |
  SimplifiedSecondaryNegation SimplifiedNegation
  deriving (Eq, Ord, Read, Show)

_SimplifiedSecondary = Core.Name "openGql.grammar.SimplifiedSecondary"

_SimplifiedSecondary_primary = Core.Name "primary"

_SimplifiedSecondary_negation = Core.Name "negation"

-- | A GQL simplified term: one of several alternative forms
data SimplifiedTerm =
  SimplifiedTermFactorLow SimplifiedFactorLow |
  SimplifiedTermConcatenation SimplifiedConcatenation
  deriving (Eq, Ord, Read, Show)

_SimplifiedTerm = Core.Name "openGql.grammar.SimplifiedTerm"

_SimplifiedTerm_factorLow = Core.Name "factorLow"

_SimplifiedTerm_concatenation = Core.Name "concatenation"

-- | A GQL simplified tertiary: one of several alternative forms
data SimplifiedTertiary =
  SimplifiedTertiaryDirectionOverride SimplifiedDirectionOverride |
  SimplifiedTertiarySecondary SimplifiedSecondary
  deriving (Eq, Ord, Read, Show)

_SimplifiedTertiary = Core.Name "openGql.grammar.SimplifiedTertiary"

_SimplifiedTertiary_directionOverride = Core.Name "directionOverride"

_SimplifiedTertiary_secondary = Core.Name "secondary"

-- | A GQL small int type
data SmallIntType =
  SmallIntType {
    smallIntTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_SmallIntType = Core.Name "openGql.grammar.SmallIntType"

_SmallIntType_notNull = Core.Name "notNull"

-- | A GQL small integer type
data SmallIntegerType =
  SmallIntegerType {
    smallIntegerTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_SmallIntegerType = Core.Name "openGql.grammar.SmallIntegerType"

_SmallIntegerType_notNull = Core.Name "notNull"

-- | A GQL sort key, equivalent to a aggregating value expression
type SortKey = AggregatingValueExpression

_SortKey = Core.Name "openGql.grammar.SortKey"

-- | A GQL sort specification
data SortSpecification =
  SortSpecification {
    sortSpecificationSortKey :: SortKey,
    sortSpecificationOrdering :: (Maybe OrderingSpecification),
    sortSpecificationNullOrdering :: (Maybe NullOrdering)}
  deriving (Eq, Ord, Read, Show)

_SortSpecification = Core.Name "openGql.grammar.SortSpecification"

_SortSpecification_sortKey = Core.Name "sortKey"

_SortSpecification_ordering = Core.Name "ordering"

_SortSpecification_nullOrdering = Core.Name "nullOrdering"

-- | A list of GQL sort specification list elements
type SortSpecificationList = [SortSpecification]

_SortSpecificationList = Core.Name "openGql.grammar.SortSpecificationList"

-- | A GQL source destination predicate: one of several alternative forms
data SourceDestinationPredicate =
  SourceDestinationPredicateSourcePredicate SourcePredicate |
  SourceDestinationPredicateDestinationPredicate DestinationPredicate
  deriving (Eq, Ord, Read, Show)

_SourceDestinationPredicate = Core.Name "openGql.grammar.SourceDestinationPredicate"

_SourceDestinationPredicate_sourcePredicate = Core.Name "sourcePredicate"

_SourceDestinationPredicate_destinationPredicate = Core.Name "destinationPredicate"

-- | A GQL source node type alias
type SourceNodeTypeAlias = String

_SourceNodeTypeAlias = Core.Name "openGql.grammar.SourceNodeTypeAlias"

-- | A GQL source node type reference: one of several alternative forms
data SourceNodeTypeReference =
  SourceNodeTypeReferenceAlias SourceNodeTypeAlias |
  SourceNodeTypeReferenceFiller (Maybe NodeTypeFiller)
  deriving (Eq, Ord, Read, Show)

_SourceNodeTypeReference = Core.Name "openGql.grammar.SourceNodeTypeReference"

_SourceNodeTypeReference_alias = Core.Name "alias"

_SourceNodeTypeReference_filler = Core.Name "filler"

-- | A GQL source predicate
data SourcePredicate =
  SourcePredicate {
    sourcePredicateNot :: Bool,
    sourcePredicateSourceOf :: EdgeReference}
  deriving (Eq, Ord, Read, Show)

_SourcePredicate = Core.Name "openGql.grammar.SourcePredicate"

_SourcePredicate_not = Core.Name "not"

_SourcePredicate_sourceOf = Core.Name "sourceOf"

-- | A GQL specified record type
data SpecifiedRecordType =
  SpecifiedRecordType {
    specifiedRecordTypeRecord :: Bool,
    specifiedRecordTypeFieldTypes :: FieldTypesSpecification,
    specifiedRecordTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_SpecifiedRecordType = Core.Name "openGql.grammar.SpecifiedRecordType"

_SpecifiedRecordType_record = Core.Name "record"

_SpecifiedRecordType_fieldTypes = Core.Name "fieldTypes"

_SpecifiedRecordType_notNull = Core.Name "notNull"

-- | A GQL square root, equivalent to a numeric value expression
type SquareRoot = NumericValueExpression

_SquareRoot = Core.Name "openGql.grammar.SquareRoot"

-- | A GQL start and maybe procedure and maybe end
data StartAndMaybeProcedureAndMaybeEnd =
  StartAndMaybeProcedureAndMaybeEnd {
    startAndMaybeProcedureAndMaybeEndStart :: StartTransactionCommand,
    startAndMaybeProcedureAndMaybeEndProcedureAndEnd :: (Maybe ProcedureAndMaybeEnd)}
  deriving (Eq, Ord, Read, Show)

_StartAndMaybeProcedureAndMaybeEnd = Core.Name "openGql.grammar.StartAndMaybeProcedureAndMaybeEnd"

_StartAndMaybeProcedureAndMaybeEnd_start = Core.Name "start"

_StartAndMaybeProcedureAndMaybeEnd_procedureAndEnd = Core.Name "procedureAndEnd"

-- | An optional GQL start transaction command
type StartTransactionCommand = (Maybe TransactionCharacteristics)

_StartTransactionCommand = Core.Name "openGql.grammar.StartTransactionCommand"

-- | A GQL statement: one of several alternative forms
data Statement =
  StatementLinearCatalogModifying LinearCatalogModifyingStatement |
  StatementLinearDataModifying LinearDataModifyingStatement |
  StatementCompositeQuery CompositeQueryStatement
  deriving (Eq, Ord, Read, Show)

_Statement = Core.Name "openGql.grammar.Statement"

_Statement_linearCatalogModifying = Core.Name "linearCatalogModifying"

_Statement_linearDataModifying = Core.Name "linearDataModifying"

_Statement_compositeQuery = Core.Name "compositeQuery"

-- | A GQL statement block
data StatementBlock =
  StatementBlock {
    statementBlockStatement :: Statement,
    statementBlockNextStatements :: [NextStatement]}
  deriving (Eq, Ord, Read, Show)

_StatementBlock = Core.Name "openGql.grammar.StatementBlock"

_StatementBlock_statement = Core.Name "statement"

_StatementBlock_nextStatements = Core.Name "nextStatements"

-- | A GQL string length, equivalent to a numeric value expression
type StringLength = NumericValueExpression

_StringLength = Core.Name "openGql.grammar.StringLength"

-- | A GQL string type
data StringType =
  StringType {
    stringTypeMinLength :: (Maybe MinLength),
    stringTypeMaxLength :: (Maybe MaxLength),
    stringTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_StringType = Core.Name "openGql.grammar.StringType"

_StringType_minLength = Core.Name "minLength"

_StringType_maxLength = Core.Name "maxLength"

_StringType_notNull = Core.Name "notNull"

-- | A GQL subtraction character or byte string
data SubCharacterOrByteString =
  SubCharacterOrByteString {
    subCharacterOrByteStringSide :: Side,
    subCharacterOrByteStringValueExpression :: ValueExpression,
    subCharacterOrByteStringStringLength :: StringLength}
  deriving (Eq, Ord, Read, Show)

_SubCharacterOrByteString = Core.Name "openGql.grammar.SubCharacterOrByteString"

_SubCharacterOrByteString_side = Core.Name "side"

_SubCharacterOrByteString_valueExpression = Core.Name "valueExpression"

_SubCharacterOrByteString_stringLength = Core.Name "stringLength"

-- | A GQL subpath variable
type SubpathVariable = String

_SubpathVariable = Core.Name "openGql.grammar.SubpathVariable"

-- | A GQL subpath variable declaration, equivalent to a subpath variable
type SubpathVariableDeclaration = SubpathVariable

_SubpathVariableDeclaration = Core.Name "openGql.grammar.SubpathVariableDeclaration"

-- | A GQL temporal duration qualifier: one of a fixed set of alternatives
data TemporalDurationQualifier =
  TemporalDurationQualifierYearToMonth |
  TemporalDurationQualifierDayToSecond
  deriving (Eq, Ord, Read, Show)

_TemporalDurationQualifier = Core.Name "openGql.grammar.TemporalDurationQualifier"

_TemporalDurationQualifier_yearToMonth = Core.Name "yearToMonth"

_TemporalDurationQualifier_dayToSecond = Core.Name "dayToSecond"

-- | A GQL temporal duration type
data TemporalDurationType =
  TemporalDurationType {
    temporalDurationTypeQualifier :: TemporalDurationQualifier,
    temporalDurationTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_TemporalDurationType = Core.Name "openGql.grammar.TemporalDurationType"

_TemporalDurationType_qualifier = Core.Name "qualifier"

_TemporalDurationType_notNull = Core.Name "notNull"

-- | A GQL temporal instant type: one of several alternative forms
data TemporalInstantType =
  TemporalInstantTypeDatetimeType DatetimeType |
  TemporalInstantTypeLocalDatetimeTypeChoice LocalDatetimeTypeChoice |
  TemporalInstantTypeDateType DateType |
  TemporalInstantTypeTimeType TimeType |
  TemporalInstantTypeLocalTimeTypeChoice LocalTimeTypeChoice
  deriving (Eq, Ord, Read, Show)

_TemporalInstantType = Core.Name "openGql.grammar.TemporalInstantType"

_TemporalInstantType_datetimeType = Core.Name "datetimeType"

_TemporalInstantType_localDatetimeTypeChoice = Core.Name "localDatetimeTypeChoice"

_TemporalInstantType_dateType = Core.Name "dateType"

_TemporalInstantType_timeType = Core.Name "timeType"

_TemporalInstantType_localTimeTypeChoice = Core.Name "localTimeTypeChoice"

-- | A GQL temporal literal: one of several alternative forms
data TemporalLiteral =
  TemporalLiteralDate DateLiteral |
  TemporalLiteralTime TimeLiteral |
  TemporalLiteralDatetime DatetimeLiteral
  deriving (Eq, Ord, Read, Show)

_TemporalLiteral = Core.Name "openGql.grammar.TemporalLiteral"

_TemporalLiteral_date = Core.Name "date"

_TemporalLiteral_time = Core.Name "time"

_TemporalLiteral_datetime = Core.Name "datetime"

-- | A GQL temporal type: one of several alternative forms
data TemporalType =
  TemporalTypeInstantType TemporalInstantType |
  TemporalTypeDurationType TemporalDurationType
  deriving (Eq, Ord, Read, Show)

_TemporalType = Core.Name "openGql.grammar.TemporalType"

_TemporalType_instantType = Core.Name "instantType"

_TemporalType_durationType = Core.Name "durationType"

-- | A GQL time function: one of several alternative forms
data TimeFunction =
  TimeFunctionCurrentTime |
  TimeFunctionZonedTimeWithParams (Maybe TimeFunctionParameters)
  deriving (Eq, Ord, Read, Show)

_TimeFunction = Core.Name "openGql.grammar.TimeFunction"

_TimeFunction_currentTime = Core.Name "currentTime"

_TimeFunction_zonedTimeWithParams = Core.Name "zonedTimeWithParams"

-- | A GQL time function parameters: one of several alternative forms
data TimeFunctionParameters =
  TimeFunctionParametersTimeString TimeString |
  TimeFunctionParametersRecordConstructor RecordConstructor
  deriving (Eq, Ord, Read, Show)

_TimeFunctionParameters = Core.Name "openGql.grammar.TimeFunctionParameters"

_TimeFunctionParameters_timeString = Core.Name "timeString"

_TimeFunctionParameters_recordConstructor = Core.Name "recordConstructor"

-- | A GQL time literal, equivalent to a time string
type TimeLiteral = TimeString

_TimeLiteral = Core.Name "openGql.grammar.TimeLiteral"

-- | A GQL time string, equivalent to a character string literal
type TimeString = CharacterStringLiteral

_TimeString = Core.Name "openGql.grammar.TimeString"

-- | A GQL time type: one of several alternative forms
data TimeType =
  TimeTypeZonedTime ZonedTimeType |
  TimeTypeTimeWithTimeZone TimeWithTimeZoneType
  deriving (Eq, Ord, Read, Show)

_TimeType = Core.Name "openGql.grammar.TimeType"

_TimeType_zonedTime = Core.Name "zonedTime"

_TimeType_timeWithTimeZone = Core.Name "timeWithTimeZone"

-- | A GQL time with time zone type
data TimeWithTimeZoneType =
  TimeWithTimeZoneType {
    timeWithTimeZoneTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_TimeWithTimeZoneType = Core.Name "openGql.grammar.TimeWithTimeZoneType"

_TimeWithTimeZoneType_notNull = Core.Name "notNull"

-- | A GQL time without time zone type
data TimeWithoutTimeZoneType =
  TimeWithoutTimeZoneType {
    timeWithoutTimeZoneTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_TimeWithoutTimeZoneType = Core.Name "openGql.grammar.TimeWithoutTimeZoneType"

_TimeWithoutTimeZoneType_notNull = Core.Name "notNull"

-- | A GQL time zone string, equivalent to a character string literal
type TimeZoneString = CharacterStringLiteral

_TimeZoneString = Core.Name "openGql.grammar.TimeZoneString"

-- | A GQL timestamp with time zone type
data TimestampWithTimeZoneType =
  TimestampWithTimeZoneType {
    timestampWithTimeZoneTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_TimestampWithTimeZoneType = Core.Name "openGql.grammar.TimestampWithTimeZoneType"

_TimestampWithTimeZoneType_notNull = Core.Name "notNull"

-- | A GQL timestamp without time zone type
data TimestampWithoutTimeZoneType =
  TimestampWithoutTimeZoneType {
    timestampWithoutTimeZoneTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_TimestampWithoutTimeZoneType = Core.Name "openGql.grammar.TimestampWithoutTimeZoneType"

_TimestampWithoutTimeZoneType_notNull = Core.Name "notNull"

-- | A GQL transaction access mode: one of a fixed set of alternatives
data TransactionAccessMode =
  TransactionAccessModeReadOnly |
  TransactionAccessModeReadWrite
  deriving (Eq, Ord, Read, Show)

_TransactionAccessMode = Core.Name "openGql.grammar.TransactionAccessMode"

_TransactionAccessMode_readOnly = Core.Name "readOnly"

_TransactionAccessMode_readWrite = Core.Name "readWrite"

-- | A GQL transaction activity: one of several alternative forms
data TransactionActivity =
  TransactionActivityStart StartAndMaybeProcedureAndMaybeEnd |
  TransactionActivityProcedure ProcedureAndMaybeEnd |
  TransactionActivityEnd EndTransactionCommand
  deriving (Eq, Ord, Read, Show)

_TransactionActivity = Core.Name "openGql.grammar.TransactionActivity"

_TransactionActivity_start = Core.Name "start"

_TransactionActivity_procedure = Core.Name "procedure"

_TransactionActivity_end = Core.Name "end"

-- | A list of GQL transaction characteristics elements
type TransactionCharacteristics = [TransactionMode]

_TransactionCharacteristics = Core.Name "openGql.grammar.TransactionCharacteristics"

-- | A GQL transaction mode, equivalent to a transaction access mode
type TransactionMode = TransactionAccessMode

_TransactionMode = Core.Name "openGql.grammar.TransactionMode"

-- | A GQL trigonometric function
data TrigonometricFunction =
  TrigonometricFunction {
    trigonometricFunctionName :: TrigonometricFunctionName,
    trigonometricFunctionValue :: NumericValueExpression}
  deriving (Eq, Ord, Read, Show)

_TrigonometricFunction = Core.Name "openGql.grammar.TrigonometricFunction"

_TrigonometricFunction_name = Core.Name "name"

_TrigonometricFunction_value = Core.Name "value"

-- | A GQL trigonometric function name: one of a fixed set of alternatives
data TrigonometricFunctionName =
  TrigonometricFunctionNameSin |
  TrigonometricFunctionNameCos |
  TrigonometricFunctionNameTan |
  TrigonometricFunctionNameCot |
  TrigonometricFunctionNameSinh |
  TrigonometricFunctionNameCosh |
  TrigonometricFunctionNameTanh |
  TrigonometricFunctionNameAsin |
  TrigonometricFunctionNameAcos |
  TrigonometricFunctionNameAtan |
  TrigonometricFunctionNameDegrees |
  TrigonometricFunctionNameRadians
  deriving (Eq, Ord, Read, Show)

_TrigonometricFunctionName = Core.Name "openGql.grammar.TrigonometricFunctionName"

_TrigonometricFunctionName_sin = Core.Name "sin"

_TrigonometricFunctionName_cos = Core.Name "cos"

_TrigonometricFunctionName_tan = Core.Name "tan"

_TrigonometricFunctionName_cot = Core.Name "cot"

_TrigonometricFunctionName_sinh = Core.Name "sinh"

_TrigonometricFunctionName_cosh = Core.Name "cosh"

_TrigonometricFunctionName_tanh = Core.Name "tanh"

_TrigonometricFunctionName_asin = Core.Name "asin"

_TrigonometricFunctionName_acos = Core.Name "acos"

_TrigonometricFunctionName_atan = Core.Name "atan"

_TrigonometricFunctionName_degrees = Core.Name "degrees"

_TrigonometricFunctionName_radians = Core.Name "radians"

-- | A GQL trim character or byte string, equivalent to a value expression
type TrimCharacterOrByteString = ValueExpression

_TrimCharacterOrByteString = Core.Name "openGql.grammar.TrimCharacterOrByteString"

-- | A GQL trim character or byte string source, equivalent to a value expression
type TrimCharacterOrByteStringSource = ValueExpression

_TrimCharacterOrByteStringSource = Core.Name "openGql.grammar.TrimCharacterOrByteStringSource"

-- | A GQL trim list function
data TrimListFunction =
  TrimListFunction {
    trimListFunctionListValue :: ListValueExpression,
    trimListFunctionNumericValue :: NumericValueExpression}
  deriving (Eq, Ord, Read, Show)

_TrimListFunction = Core.Name "openGql.grammar.TrimListFunction"

_TrimListFunction_listValue = Core.Name "listValue"

_TrimListFunction_numericValue = Core.Name "numericValue"

-- | A GQL trim multi character character string
data TrimMultiCharacterCharacterString =
  TrimMultiCharacterCharacterString {
    trimMultiCharacterCharacterStringTrimType :: TrimType,
    trimMultiCharacterCharacterStringValueExpression :: ValueExpression,
    trimMultiCharacterCharacterStringOptionalValueExpression :: (Maybe ValueExpression)}
  deriving (Eq, Ord, Read, Show)

_TrimMultiCharacterCharacterString = Core.Name "openGql.grammar.TrimMultiCharacterCharacterString"

_TrimMultiCharacterCharacterString_trimType = Core.Name "trimType"

_TrimMultiCharacterCharacterString_valueExpression = Core.Name "valueExpression"

_TrimMultiCharacterCharacterString_optionalValueExpression = Core.Name "optionalValueExpression"

-- | A GQL trim operands
data TrimOperands =
  TrimOperands {
    trimOperandsSpecification :: (Maybe TrimSpecification),
    trimOperandsCharacterOrByteString :: (Maybe TrimCharacterOrByteString),
    trimOperandsSource :: TrimCharacterOrByteStringSource}
  deriving (Eq, Ord, Read, Show)

_TrimOperands = Core.Name "openGql.grammar.TrimOperands"

_TrimOperands_specification = Core.Name "specification"

_TrimOperands_characterOrByteString = Core.Name "characterOrByteString"

_TrimOperands_source = Core.Name "source"

-- | A GQL trim single character or byte string, equivalent to a trim operands
type TrimSingleCharacterOrByteString = TrimOperands

_TrimSingleCharacterOrByteString = Core.Name "openGql.grammar.TrimSingleCharacterOrByteString"

-- | A GQL trim specification: one of a fixed set of alternatives
data TrimSpecification =
  TrimSpecificationLeading |
  TrimSpecificationTrailing |
  TrimSpecificationBoth
  deriving (Eq, Ord, Read, Show)

_TrimSpecification = Core.Name "openGql.grammar.TrimSpecification"

_TrimSpecification_leading = Core.Name "leading"

_TrimSpecification_trailing = Core.Name "trailing"

_TrimSpecification_both = Core.Name "both"

-- | A GQL trim type: one of a fixed set of alternatives
data TrimType =
  TrimTypeBtrim |
  TrimTypeLtrim |
  TrimTypeRtrim
  deriving (Eq, Ord, Read, Show)

_TrimType = Core.Name "openGql.grammar.TrimType"

_TrimType_btrim = Core.Name "btrim"

_TrimType_ltrim = Core.Name "ltrim"

_TrimType_rtrim = Core.Name "rtrim"

-- | A GQL truth value, equivalent to a boolean literal
type TruthValue = BooleanLiteral

_TruthValue = Core.Name "openGql.grammar.TruthValue"

-- | A GQL typed
type Typed = ()

_Typed = Core.Name "openGql.grammar.Typed"

-- | A GQL typed binding table reference value type
data TypedBindingTableReferenceValueType =
  TypedBindingTableReferenceValueType {
    typedBindingTableReferenceValueTypeTyped :: (Maybe Typed),
    typedBindingTableReferenceValueTypeValueType :: BindingTableReferenceValueType}
  deriving (Eq, Ord, Read, Show)

_TypedBindingTableReferenceValueType = Core.Name "openGql.grammar.TypedBindingTableReferenceValueType"

_TypedBindingTableReferenceValueType_typed = Core.Name "typed"

_TypedBindingTableReferenceValueType_valueType = Core.Name "valueType"

-- | A GQL typed graph reference value type
data TypedGraphReferenceValueType =
  TypedGraphReferenceValueType {
    typedGraphReferenceValueTypeTyped :: (Maybe Typed),
    typedGraphReferenceValueTypeValueType :: GraphReferenceValueType}
  deriving (Eq, Ord, Read, Show)

_TypedGraphReferenceValueType = Core.Name "openGql.grammar.TypedGraphReferenceValueType"

_TypedGraphReferenceValueType_typed = Core.Name "typed"

_TypedGraphReferenceValueType_valueType = Core.Name "valueType"

-- | A GQL typed graph type reference
data TypedGraphTypeReference =
  TypedGraphTypeReference {
    typedGraphTypeReferenceTyped :: (Maybe Typed),
    typedGraphTypeReferenceReference :: GraphTypeReference}
  deriving (Eq, Ord, Read, Show)

_TypedGraphTypeReference = Core.Name "openGql.grammar.TypedGraphTypeReference"

_TypedGraphTypeReference_typed = Core.Name "typed"

_TypedGraphTypeReference_reference = Core.Name "reference"

-- | A GQL typed nested graph type specification
data TypedNestedGraphTypeSpecification =
  TypedNestedGraphTypeSpecification {
    typedNestedGraphTypeSpecificationTyped :: (Maybe Typed),
    typedNestedGraphTypeSpecificationGraph :: Bool,
    typedNestedGraphTypeSpecificationSpecification :: NestedGraphTypeSpecification}
  deriving (Eq, Ord, Read, Show)

_TypedNestedGraphTypeSpecification = Core.Name "openGql.grammar.TypedNestedGraphTypeSpecification"

_TypedNestedGraphTypeSpecification_typed = Core.Name "typed"

_TypedNestedGraphTypeSpecification_graph = Core.Name "graph"

_TypedNestedGraphTypeSpecification_specification = Core.Name "specification"

-- | A GQL typed value type
data TypedValueType =
  TypedValueType {
    typedValueTypeTyped :: (Maybe Typed),
    typedValueTypeValueType :: ValueType}
  deriving (Eq, Ord, Read, Show)

_TypedValueType = Core.Name "openGql.grammar.TypedValueType"

_TypedValueType_typed = Core.Name "typed"

_TypedValueType_valueType = Core.Name "valueType"

-- | A GQL u big int type
data UBigIntType =
  UBigIntType {
    uBigIntTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_UBigIntType = Core.Name "openGql.grammar.UBigIntType"

_UBigIntType_notNull = Core.Name "notNull"

-- | A GQL u small int type
data USmallIntType =
  USmallIntType {
    uSmallIntTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_USmallIntType = Core.Name "openGql.grammar.USmallIntType"

_USmallIntType_notNull = Core.Name "notNull"

-- | A GQL uint128 type
data Uint128Type =
  Uint128Type {
    uint128TypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_Uint128Type = Core.Name "openGql.grammar.Uint128Type"

_Uint128Type_notNull = Core.Name "notNull"

-- | A GQL uint16 type
data Uint16Type =
  Uint16Type {
    uint16TypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_Uint16Type = Core.Name "openGql.grammar.Uint16Type"

_Uint16Type_notNull = Core.Name "notNull"

-- | A GQL uint256 type
data Uint256Type =
  Uint256Type {
    uint256TypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_Uint256Type = Core.Name "openGql.grammar.Uint256Type"

_Uint256Type_notNull = Core.Name "notNull"

-- | A GQL uint32 type
data Uint32Type =
  Uint32Type {
    uint32TypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_Uint32Type = Core.Name "openGql.grammar.Uint32Type"

_Uint32Type_notNull = Core.Name "notNull"

-- | A GQL uint64 type
data Uint64Type =
  Uint64Type {
    uint64TypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_Uint64Type = Core.Name "openGql.grammar.Uint64Type"

_Uint64Type_notNull = Core.Name "notNull"

-- | A GQL uint8 type
data Uint8Type =
  Uint8Type {
    uint8TypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_Uint8Type = Core.Name "openGql.grammar.Uint8Type"

_Uint8Type_notNull = Core.Name "notNull"

-- | A GQL uint with precision
data UintWithPrecision =
  UintWithPrecision {
    uintWithPrecisionPrecision :: (Maybe Precision),
    uintWithPrecisionNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_UintWithPrecision = Core.Name "openGql.grammar.UintWithPrecision"

_UintWithPrecision_precision = Core.Name "precision"

_UintWithPrecision_notNull = Core.Name "notNull"

-- | A GQL unsigned binary exact numeric type: one of several alternative forms
data UnsignedBinaryExactNumericType =
  UnsignedBinaryExactNumericTypeUint8 Uint8Type |
  UnsignedBinaryExactNumericTypeUint16 Uint16Type |
  UnsignedBinaryExactNumericTypeUint32 Uint32Type |
  UnsignedBinaryExactNumericTypeUint64 Uint64Type |
  UnsignedBinaryExactNumericTypeUint128 Uint128Type |
  UnsignedBinaryExactNumericTypeUint256 Uint256Type |
  UnsignedBinaryExactNumericTypeUSmallInt USmallIntType |
  UnsignedBinaryExactNumericTypeUintWithPrecision UintWithPrecision |
  UnsignedBinaryExactNumericTypeUBigInt UBigIntType |
  UnsignedBinaryExactNumericTypeUnsigned VerboseBinaryExactNumericType
  deriving (Eq, Ord, Read, Show)

_UnsignedBinaryExactNumericType = Core.Name "openGql.grammar.UnsignedBinaryExactNumericType"

_UnsignedBinaryExactNumericType_uint8 = Core.Name "uint8"

_UnsignedBinaryExactNumericType_uint16 = Core.Name "uint16"

_UnsignedBinaryExactNumericType_uint32 = Core.Name "uint32"

_UnsignedBinaryExactNumericType_uint64 = Core.Name "uint64"

_UnsignedBinaryExactNumericType_uint128 = Core.Name "uint128"

_UnsignedBinaryExactNumericType_uint256 = Core.Name "uint256"

_UnsignedBinaryExactNumericType_uSmallInt = Core.Name "uSmallInt"

_UnsignedBinaryExactNumericType_uintWithPrecision = Core.Name "uintWithPrecision"

_UnsignedBinaryExactNumericType_uBigInt = Core.Name "uBigInt"

_UnsignedBinaryExactNumericType_unsigned = Core.Name "unsigned"

-- | A GQL unsigned decimal integer
type UnsignedDecimalInteger = String

_UnsignedDecimalInteger = Core.Name "openGql.grammar.UnsignedDecimalInteger"

-- | A GQL unsigned integer: one of several alternative forms
data UnsignedInteger =
  UnsignedIntegerDecimal String |
  UnsignedIntegerHexadecimal String |
  UnsignedIntegerOctal String |
  UnsignedIntegerBinary String
  deriving (Eq, Ord, Read, Show)

_UnsignedInteger = Core.Name "openGql.grammar.UnsignedInteger"

_UnsignedInteger_decimal = Core.Name "decimal"

_UnsignedInteger_hexadecimal = Core.Name "hexadecimal"

_UnsignedInteger_octal = Core.Name "octal"

_UnsignedInteger_binary = Core.Name "binary"

-- | A GQL unsigned literal: one of several alternative forms
data UnsignedLiteral =
  UnsignedLiteralNumeric UnsignedNumericLiteral |
  UnsignedLiteralGeneral GeneralLiteral
  deriving (Eq, Ord, Read, Show)

_UnsignedLiteral = Core.Name "openGql.grammar.UnsignedLiteral"

_UnsignedLiteral_numeric = Core.Name "numeric"

_UnsignedLiteral_general = Core.Name "general"

-- | A GQL unsigned numeric literal: one of several alternative forms
data UnsignedNumericLiteral =
  UnsignedNumericLiteralExact ExactNumericLiteral |
  UnsignedNumericLiteralApproximate ApproximateNumericLiteral
  deriving (Eq, Ord, Read, Show)

_UnsignedNumericLiteral = Core.Name "openGql.grammar.UnsignedNumericLiteral"

_UnsignedNumericLiteral_exact = Core.Name "exact"

_UnsignedNumericLiteral_approximate = Core.Name "approximate"

-- | A GQL unsigned value specification: one of several alternative forms
data UnsignedValueSpecification =
  UnsignedValueSpecificationUnsignedLiteral UnsignedLiteral |
  UnsignedValueSpecificationGeneralValueSpecification GeneralValueSpecification
  deriving (Eq, Ord, Read, Show)

_UnsignedValueSpecification = Core.Name "openGql.grammar.UnsignedValueSpecification"

_UnsignedValueSpecification_unsignedLiteral = Core.Name "unsignedLiteral"

_UnsignedValueSpecification_generalValueSpecification = Core.Name "generalValueSpecification"

-- | A GQL upper bound, equivalent to a unsigned integer
type UpperBound = UnsignedInteger

_UpperBound = Core.Name "openGql.grammar.UpperBound"

-- | A GQL use graph clause, equivalent to a graph expression
type UseGraphClause = GraphExpression

_UseGraphClause = Core.Name "openGql.grammar.UseGraphClause"

-- | A GQL value expression: one of several alternative forms
data ValueExpression =
  ValueExpressionSigned SignedExpr |
  ValueExpressionMultDiv MultDivExpr |
  ValueExpressionAddSubtract AddSubtractExpr |
  ValueExpressionConcatenation ConcatenationExpr |
  ValueExpressionNot NotExpr |
  ValueExpressionIsNot IsNotExpr |
  ValueExpressionConjunctive ConjunctiveExpr |
  ValueExpressionDisjunctive DisjunctiveExpr |
  ValueExpressionComparison ComparisonExpr |
  ValueExpressionPredicate Predicate |
  ValueExpressionNormalizedPredicate NormalizedPredicateExpr |
  ValueExpressionPropertyGraph GraphExpression |
  ValueExpressionBindingTable BindingTableExpression |
  ValueExpressionValueFunction ValueFunction |
  ValueExpressionPrimary PrimaryValueExpression
  deriving (Eq, Ord, Read, Show)

_ValueExpression = Core.Name "openGql.grammar.ValueExpression"

_ValueExpression_signed = Core.Name "signed"

_ValueExpression_multDiv = Core.Name "multDiv"

_ValueExpression_addSubtract = Core.Name "addSubtract"

_ValueExpression_concatenation = Core.Name "concatenation"

_ValueExpression_not = Core.Name "not"

_ValueExpression_isNot = Core.Name "isNot"

_ValueExpression_conjunctive = Core.Name "conjunctive"

_ValueExpression_disjunctive = Core.Name "disjunctive"

_ValueExpression_comparison = Core.Name "comparison"

_ValueExpression_predicate = Core.Name "predicate"

_ValueExpression_normalizedPredicate = Core.Name "normalizedPredicate"

_ValueExpression_propertyGraph = Core.Name "propertyGraph"

_ValueExpression_bindingTable = Core.Name "bindingTable"

_ValueExpression_valueFunction = Core.Name "valueFunction"

_ValueExpression_primary = Core.Name "primary"

-- | A GQL value function: one of several alternative forms
data ValueFunction =
  ValueFunctionNumeric NumericValueFunction |
  ValueFunctionDatetimeSubtraction DatetimeSubtraction |
  ValueFunctionDatetime DatetimeValueFunction |
  ValueFunctionDuration DurationValueFunction |
  ValueFunctionCharacterOrByteString CharacterOrByteStringFunction |
  ValueFunctionList ListValueFunction
  deriving (Eq, Ord, Read, Show)

_ValueFunction = Core.Name "openGql.grammar.ValueFunction"

_ValueFunction_numeric = Core.Name "numeric"

_ValueFunction_datetimeSubtraction = Core.Name "datetimeSubtraction"

_ValueFunction_datetime = Core.Name "datetime"

_ValueFunction_duration = Core.Name "duration"

_ValueFunction_characterOrByteString = Core.Name "characterOrByteString"

_ValueFunction_list = Core.Name "list"

-- | A GQL value initializer
type ValueInitializer = ()

_ValueInitializer = Core.Name "openGql.grammar.ValueInitializer"

-- | A GQL value query expression, equivalent to a nested query specification
type ValueQueryExpression = NestedQuerySpecification

_ValueQueryExpression = Core.Name "openGql.grammar.ValueQueryExpression"

-- | A GQL value type: one of several alternative forms
data ValueType =
  ValueTypePredefinedType PredefinedType |
  ValueTypePathValueType PathValueType |
  ValueTypeListValueTypeAlt1 ListValueTypeAlt1 |
  ValueTypeListValueTypeAlt2 ListValueTypeAlt2 |
  ValueTypeListValueTypeAlt3 ListValueTypeAlt3 |
  ValueTypeRecordType RecordType |
  ValueTypeOpenDynamicUnionType OpenDynamicUnionType |
  ValueTypeDynamicPropertyValueType DynamicPropertyValueType |
  ValueTypeClosedDynamicUnionTypeAlt1 ClosedDynamicUnionTypeAlt1 |
  ValueTypeClosedDynamicUnionTypeAlt2 ClosedDynamicUnionTypeAlt2
  deriving (Eq, Ord, Read, Show)

_ValueType = Core.Name "openGql.grammar.ValueType"

_ValueType_predefinedType = Core.Name "predefinedType"

_ValueType_pathValueType = Core.Name "pathValueType"

_ValueType_listValueTypeAlt1 = Core.Name "listValueTypeAlt1"

_ValueType_listValueTypeAlt2 = Core.Name "listValueTypeAlt2"

_ValueType_listValueTypeAlt3 = Core.Name "listValueTypeAlt3"

_ValueType_recordType = Core.Name "recordType"

_ValueType_openDynamicUnionType = Core.Name "openDynamicUnionType"

_ValueType_dynamicPropertyValueType = Core.Name "dynamicPropertyValueType"

_ValueType_closedDynamicUnionTypeAlt1 = Core.Name "closedDynamicUnionTypeAlt1"

_ValueType_closedDynamicUnionTypeAlt2 = Core.Name "closedDynamicUnionTypeAlt2"

-- | A GQL value type predicate
data ValueTypePredicate =
  ValueTypePredicate {
    valueTypePredicateValueExpression :: PrimaryValueExpression,
    valueTypePredicateValueTypePart :: ValueTypePredicatePart2}
  deriving (Eq, Ord, Read, Show)

_ValueTypePredicate = Core.Name "openGql.grammar.ValueTypePredicate"

_ValueTypePredicate_valueExpression = Core.Name "valueExpression"

_ValueTypePredicate_valueTypePart = Core.Name "valueTypePart"

-- | A GQL value type predicate part2
data ValueTypePredicatePart2 =
  ValueTypePredicatePart2 {
    valueTypePredicatePart2Not :: Bool,
    valueTypePredicatePart2Typed :: Typed,
    valueTypePredicatePart2ValueType :: ValueType}
  deriving (Eq, Ord, Read, Show)

_ValueTypePredicatePart2 = Core.Name "openGql.grammar.ValueTypePredicatePart2"

_ValueTypePredicatePart2_not = Core.Name "not"

_ValueTypePredicatePart2_typed = Core.Name "typed"

_ValueTypePredicatePart2_valueType = Core.Name "valueType"

-- | A GQL value variable definition
data ValueVariableDefinition =
  ValueVariableDefinition {
    valueVariableDefinitionVariable :: BindingVariable,
    valueVariableDefinitionInitializer :: OptTypedValueInitializer}
  deriving (Eq, Ord, Read, Show)

_ValueVariableDefinition = Core.Name "openGql.grammar.ValueVariableDefinition"

_ValueVariableDefinition_variable = Core.Name "variable"

_ValueVariableDefinition_initializer = Core.Name "initializer"

-- | A GQL varbinary type
data VarbinaryType =
  VarbinaryType {
    varbinaryTypeMaxLength :: (Maybe MaxLength),
    varbinaryTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_VarbinaryType = Core.Name "openGql.grammar.VarbinaryType"

_VarbinaryType_maxLength = Core.Name "maxLength"

_VarbinaryType_notNull = Core.Name "notNull"

-- | A GQL varchar type
data VarcharType =
  VarcharType {
    varcharTypeMaxLength :: (Maybe MaxLength),
    varcharTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_VarcharType = Core.Name "openGql.grammar.VarcharType"

_VarcharType_maxLength = Core.Name "maxLength"

_VarcharType_notNull = Core.Name "notNull"

-- | An optional GQL variable scope clause
type VariableScopeClause = (Maybe BindingVariableReferenceList)

_VariableScopeClause = Core.Name "openGql.grammar.VariableScopeClause"

-- | A GQL verbose binary exact numeric type: one of several alternative forms
data VerboseBinaryExactNumericType =
  VerboseBinaryExactNumericTypeInteger8 Integer8Type |
  VerboseBinaryExactNumericTypeInteger16 Integer16Type |
  VerboseBinaryExactNumericTypeInteger32 Integer32Type |
  VerboseBinaryExactNumericTypeInteger64 Integer64Type |
  VerboseBinaryExactNumericTypeInteger128 Integer128Type |
  VerboseBinaryExactNumericTypeInteger256 Integer256Type |
  VerboseBinaryExactNumericTypeSmallInteger SmallIntegerType |
  VerboseBinaryExactNumericTypeIntegerWithPrecision IntegerWithPrecision |
  VerboseBinaryExactNumericTypeBigInteger BigIntegerType
  deriving (Eq, Ord, Read, Show)

_VerboseBinaryExactNumericType = Core.Name "openGql.grammar.VerboseBinaryExactNumericType"

_VerboseBinaryExactNumericType_integer8 = Core.Name "integer8"

_VerboseBinaryExactNumericType_integer16 = Core.Name "integer16"

_VerboseBinaryExactNumericType_integer32 = Core.Name "integer32"

_VerboseBinaryExactNumericType_integer64 = Core.Name "integer64"

_VerboseBinaryExactNumericType_integer128 = Core.Name "integer128"

_VerboseBinaryExactNumericType_integer256 = Core.Name "integer256"

_VerboseBinaryExactNumericType_smallInteger = Core.Name "smallInteger"

_VerboseBinaryExactNumericType_integerWithPrecision = Core.Name "integerWithPrecision"

_VerboseBinaryExactNumericType_bigInteger = Core.Name "bigInteger"

-- | A GQL when operand: one of several alternative forms
data WhenOperand =
  WhenOperandValueExpression NonParenthesizedPrimaryValueExpression |
  WhenOperandComparison ComparisonPredicatePart2 |
  WhenOperandNullPredicate NullPredicatePart2 |
  WhenOperandValueTypePredicate ValueTypePredicatePart2 |
  WhenOperandNormalizedPredicate NormalizedPredicatePart2 |
  WhenOperandDirectedPredicate DirectedPredicatePart2 |
  WhenOperandLabeledPredicate LabeledPredicatePart2 |
  WhenOperandSourcePredicate SourcePredicate |
  WhenOperandDestinationPredicate DestinationPredicate
  deriving (Eq, Ord, Read, Show)

_WhenOperand = Core.Name "openGql.grammar.WhenOperand"

_WhenOperand_valueExpression = Core.Name "valueExpression"

_WhenOperand_comparison = Core.Name "comparison"

_WhenOperand_nullPredicate = Core.Name "nullPredicate"

_WhenOperand_valueTypePredicate = Core.Name "valueTypePredicate"

_WhenOperand_normalizedPredicate = Core.Name "normalizedPredicate"

_WhenOperand_directedPredicate = Core.Name "directedPredicate"

_WhenOperand_labeledPredicate = Core.Name "labeledPredicate"

_WhenOperand_sourcePredicate = Core.Name "sourcePredicate"

_WhenOperand_destinationPredicate = Core.Name "destinationPredicate"

-- | A list of GQL when operand list elements
type WhenOperandList = [WhenOperand]

_WhenOperandList = Core.Name "openGql.grammar.WhenOperandList"

-- | A GQL where clause, equivalent to a search condition
type WhereClause = SearchCondition

_WhereClause = Core.Name "openGql.grammar.WhereClause"

-- | A GQL yield clause, equivalent to a yield item list
type YieldClause = YieldItemList

_YieldClause = Core.Name "openGql.grammar.YieldClause"

-- | A GQL yield item
data YieldItem =
  YieldItem {
    yieldItemName :: YieldItemName,
    yieldItemAlias :: (Maybe YieldItemAlias)}
  deriving (Eq, Ord, Read, Show)

_YieldItem = Core.Name "openGql.grammar.YieldItem"

_YieldItem_name = Core.Name "name"

_YieldItem_alias = Core.Name "alias"

-- | A GQL yield item alias, equivalent to a binding variable
type YieldItemAlias = BindingVariable

_YieldItemAlias = Core.Name "openGql.grammar.YieldItemAlias"

-- | A list of GQL yield item list elements
type YieldItemList = [YieldItem]

_YieldItemList = Core.Name "openGql.grammar.YieldItemList"

-- | A GQL yield item name, equivalent to a field name
type YieldItemName = FieldName

_YieldItemName = Core.Name "openGql.grammar.YieldItemName"

-- | A GQL zoned datetime type
data ZonedDatetimeType =
  ZonedDatetimeType {
    zonedDatetimeTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_ZonedDatetimeType = Core.Name "openGql.grammar.ZonedDatetimeType"

_ZonedDatetimeType_notNull = Core.Name "notNull"

-- | A GQL zoned time type
data ZonedTimeType =
  ZonedTimeType {
    zonedTimeTypeNotNull :: Bool}
  deriving (Eq, Ord, Read, Show)

_ZonedTimeType = Core.Name "openGql.grammar.ZonedTimeType"

_ZonedTimeType_notNull = Core.Name "notNull"