Syntax.hs

-- | A C# syntax module based on the ANTLR grammar dated 02/07/2024 and available at:
-- |   https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/grammar

module Hydra.Ext.Csharp.Syntax where

import qualified Hydra.Core as Core
import Data.Int
import Data.List as L
import Data.Map as M
import Data.Set as S

newtype Identifier = 
  Identifier {
    unIdentifier :: String}
  deriving (Eq, Ord, Read, Show)

_Identifier = (Core.Name "hydra/ext/csharp/syntax.Identifier")

newtype Keyword = 
  Keyword {
    unKeyword :: String}
  deriving (Eq, Ord, Read, Show)

_Keyword = (Core.Name "hydra/ext/csharp/syntax.Keyword")

data Literal = 
  LiteralBoolean Bool |
  LiteralInteger IntegerLiteral |
  LiteralReal Double |
  LiteralCharacter String |
  LiteralString String |
  LiteralNull 
  deriving (Eq, Ord, Read, Show)

_Literal = (Core.Name "hydra/ext/csharp/syntax.Literal")

_Literal_boolean = (Core.Name "boolean")

_Literal_integer = (Core.Name "integer")

_Literal_real = (Core.Name "real")

_Literal_character = (Core.Name "character")

_Literal_string = (Core.Name "string")

_Literal_null = (Core.Name "null")

data IntegerLiteral = 
  IntegerLiteralDecimal String |
  IntegerLiteralHexadecimal String |
  IntegerLiteralBinary Integer
  deriving (Eq, Ord, Read, Show)

_IntegerLiteral = (Core.Name "hydra/ext/csharp/syntax.IntegerLiteral")

_IntegerLiteral_decimal = (Core.Name "decimal")

_IntegerLiteral_hexadecimal = (Core.Name "hexadecimal")

_IntegerLiteral_binary = (Core.Name "binary")

newtype NamespaceName = 
  NamespaceName {
    unNamespaceName :: NamespaceOrTypeName}
  deriving (Eq, Ord, Read, Show)

_NamespaceName = (Core.Name "hydra/ext/csharp/syntax.NamespaceName")

newtype TypeName = 
  TypeName {
    unTypeName :: NamespaceOrTypeName}
  deriving (Eq, Ord, Read, Show)

_TypeName = (Core.Name "hydra/ext/csharp/syntax.TypeName")

data NamespaceOrTypeName = 
  NamespaceOrTypeNameIdentifier IdentifierNamespaceOrTypeName |
  NamespaceOrTypeNameQualified QualifiedNamespaceOrTypeName |
  NamespaceOrTypeNameAlias QualifiedAliasMember
  deriving (Eq, Ord, Read, Show)

_NamespaceOrTypeName = (Core.Name "hydra/ext/csharp/syntax.NamespaceOrTypeName")

_NamespaceOrTypeName_identifier = (Core.Name "identifier")

_NamespaceOrTypeName_qualified = (Core.Name "qualified")

_NamespaceOrTypeName_alias = (Core.Name "alias")

data IdentifierNamespaceOrTypeName = 
  IdentifierNamespaceOrTypeName {
    identifierNamespaceOrTypeNameIdentifier :: Identifier,
    identifierNamespaceOrTypeNameArguments :: (Maybe TypeArgumentList)}
  deriving (Eq, Ord, Read, Show)

_IdentifierNamespaceOrTypeName = (Core.Name "hydra/ext/csharp/syntax.IdentifierNamespaceOrTypeName")

_IdentifierNamespaceOrTypeName_identifier = (Core.Name "identifier")

_IdentifierNamespaceOrTypeName_arguments = (Core.Name "arguments")

data QualifiedNamespaceOrTypeName = 
  QualifiedNamespaceOrTypeName {
    qualifiedNamespaceOrTypeNameNamespaceOrType :: NamespaceOrTypeName,
    qualifiedNamespaceOrTypeNameIdentifier :: Identifier,
    qualifiedNamespaceOrTypeNameArguments :: (Maybe TypeArgumentList)}
  deriving (Eq, Ord, Read, Show)

_QualifiedNamespaceOrTypeName = (Core.Name "hydra/ext/csharp/syntax.QualifiedNamespaceOrTypeName")

_QualifiedNamespaceOrTypeName_namespaceOrType = (Core.Name "namespaceOrType")

_QualifiedNamespaceOrTypeName_identifier = (Core.Name "identifier")

_QualifiedNamespaceOrTypeName_arguments = (Core.Name "arguments")

data Type = 
  TypeReference ReferenceType |
  TypeValue ValueType |
  TypeParam TypeParameter |
  TypePointer PointerType
  deriving (Eq, Ord, Read, Show)

_Type = (Core.Name "hydra/ext/csharp/syntax.Type")

_Type_reference = (Core.Name "reference")

_Type_value = (Core.Name "value")

_Type_param = (Core.Name "param")

_Type_pointer = (Core.Name "pointer")

data ReferenceType = 
  ReferenceTypeClass ClassType |
  ReferenceTypeInterface InterfaceType |
  ReferenceTypeArray ArrayType |
  ReferenceTypeDelegate DelegateType |
  ReferenceTypeDynamic 
  deriving (Eq, Ord, Read, Show)

_ReferenceType = (Core.Name "hydra/ext/csharp/syntax.ReferenceType")

_ReferenceType_class = (Core.Name "class")

_ReferenceType_interface = (Core.Name "interface")

_ReferenceType_array = (Core.Name "array")

_ReferenceType_delegate = (Core.Name "delegate")

_ReferenceType_dynamic = (Core.Name "dynamic")

data ClassType = 
  ClassTypeTypeName TypeName |
  ClassTypeObject  |
  ClassTypeString 
  deriving (Eq, Ord, Read, Show)

_ClassType = (Core.Name "hydra/ext/csharp/syntax.ClassType")

_ClassType_typeName = (Core.Name "typeName")

_ClassType_object = (Core.Name "object")

_ClassType_string = (Core.Name "string")

newtype InterfaceType = 
  InterfaceType {
    unInterfaceType :: TypeName}
  deriving (Eq, Ord, Read, Show)

_InterfaceType = (Core.Name "hydra/ext/csharp/syntax.InterfaceType")

data ArrayType = 
  ArrayType {
    arrayTypeType :: NonArrayType,
    arrayTypeRank :: [RankSpecifier]}
  deriving (Eq, Ord, Read, Show)

_ArrayType = (Core.Name "hydra/ext/csharp/syntax.ArrayType")

_ArrayType_type = (Core.Name "type")

_ArrayType_rank = (Core.Name "rank")

data NonArrayType = 
  NonArrayTypeValue ValueType |
  NonArrayTypeClass ClassType |
  NonArrayTypeInterface InterfaceType |
  NonArrayTypeDelegate DelegateType |
  NonArrayTypeDynamic  |
  NonArrayTypeParameter TypeParameter |
  NonArrayTypePointer PointerType
  deriving (Eq, Ord, Read, Show)

_NonArrayType = (Core.Name "hydra/ext/csharp/syntax.NonArrayType")

_NonArrayType_value = (Core.Name "value")

_NonArrayType_class = (Core.Name "class")

_NonArrayType_interface = (Core.Name "interface")

_NonArrayType_delegate = (Core.Name "delegate")

_NonArrayType_dynamic = (Core.Name "dynamic")

_NonArrayType_parameter = (Core.Name "parameter")

_NonArrayType_pointer = (Core.Name "pointer")

newtype RankSpecifier = 
  RankSpecifier {
    unRankSpecifier :: Int}
  deriving (Eq, Ord, Read, Show)

_RankSpecifier = (Core.Name "hydra/ext/csharp/syntax.RankSpecifier")

newtype DelegateType = 
  DelegateType {
    unDelegateType :: TypeName}
  deriving (Eq, Ord, Read, Show)

_DelegateType = (Core.Name "hydra/ext/csharp/syntax.DelegateType")

data ValueType = 
  ValueTypeNonNullable StructOrEnumType |
  ValueTypeNullable StructOrEnumType
  deriving (Eq, Ord, Read, Show)

_ValueType = (Core.Name "hydra/ext/csharp/syntax.ValueType")

_ValueType_nonNullable = (Core.Name "nonNullable")

_ValueType_nullable = (Core.Name "nullable")

data StructOrEnumType = 
  StructOrEnumTypeStruct StructType |
  StructOrEnumTypeEnum EnumType
  deriving (Eq, Ord, Read, Show)

_StructOrEnumType = (Core.Name "hydra/ext/csharp/syntax.StructOrEnumType")

_StructOrEnumType_struct = (Core.Name "struct")

_StructOrEnumType_enum = (Core.Name "enum")

data StructType = 
  StructTypeTypeName TypeName |
  StructTypeSimple SimpleType |
  StructTypeTuple TupleType
  deriving (Eq, Ord, Read, Show)

_StructType = (Core.Name "hydra/ext/csharp/syntax.StructType")

_StructType_typeName = (Core.Name "typeName")

_StructType_simple = (Core.Name "simple")

_StructType_tuple = (Core.Name "tuple")

data SimpleType = 
  SimpleTypeNumeric NumericType |
  SimpleTypeBool 
  deriving (Eq, Ord, Read, Show)

_SimpleType = (Core.Name "hydra/ext/csharp/syntax.SimpleType")

_SimpleType_numeric = (Core.Name "numeric")

_SimpleType_bool = (Core.Name "bool")

data NumericType = 
  NumericTypeIntegral IntegralType |
  NumericTypeFloatingPoint FloatingPointType |
  NumericTypeDecimal 
  deriving (Eq, Ord, Read, Show)

_NumericType = (Core.Name "hydra/ext/csharp/syntax.NumericType")

_NumericType_integral = (Core.Name "integral")

_NumericType_floatingPoint = (Core.Name "floatingPoint")

_NumericType_decimal = (Core.Name "decimal")

data IntegralType = 
  IntegralTypeSbyte  |
  IntegralTypeByte  |
  IntegralTypeShort  |
  IntegralTypeUshort  |
  IntegralTypeInt  |
  IntegralTypeUint  |
  IntegralTypeLong  |
  IntegralTypeUlong  |
  IntegralTypeChar 
  deriving (Eq, Ord, Read, Show)

_IntegralType = (Core.Name "hydra/ext/csharp/syntax.IntegralType")

_IntegralType_sbyte = (Core.Name "sbyte")

_IntegralType_byte = (Core.Name "byte")

_IntegralType_short = (Core.Name "short")

_IntegralType_ushort = (Core.Name "ushort")

_IntegralType_int = (Core.Name "int")

_IntegralType_uint = (Core.Name "uint")

_IntegralType_long = (Core.Name "long")

_IntegralType_ulong = (Core.Name "ulong")

_IntegralType_char = (Core.Name "char")

data FloatingPointType = 
  FloatingPointTypeFloat  |
  FloatingPointTypeDouble 
  deriving (Eq, Ord, Read, Show)

_FloatingPointType = (Core.Name "hydra/ext/csharp/syntax.FloatingPointType")

_FloatingPointType_float = (Core.Name "float")

_FloatingPointType_double = (Core.Name "double")

newtype TupleType = 
  TupleType {
    unTupleType :: [TupleTypeElement]}
  deriving (Eq, Ord, Read, Show)

_TupleType = (Core.Name "hydra/ext/csharp/syntax.TupleType")

data TupleTypeElement = 
  TupleTypeElement {
    tupleTypeElementType :: Type,
    tupleTypeElementIdentifier :: (Maybe Identifier)}
  deriving (Eq, Ord, Read, Show)

_TupleTypeElement = (Core.Name "hydra/ext/csharp/syntax.TupleTypeElement")

_TupleTypeElement_type = (Core.Name "type")

_TupleTypeElement_identifier = (Core.Name "identifier")

newtype EnumType = 
  EnumType {
    unEnumType :: TypeName}
  deriving (Eq, Ord, Read, Show)

_EnumType = (Core.Name "hydra/ext/csharp/syntax.EnumType")

newtype TypeArgumentList = 
  TypeArgumentList {
    unTypeArgumentList :: [Type]}
  deriving (Eq, Ord, Read, Show)

_TypeArgumentList = (Core.Name "hydra/ext/csharp/syntax.TypeArgumentList")

newtype TypeParameter = 
  TypeParameter {
    unTypeParameter :: Identifier}
  deriving (Eq, Ord, Read, Show)

_TypeParameter = (Core.Name "hydra/ext/csharp/syntax.TypeParameter")

data UnmanagedType = 
  UnmanagedTypeValue ValueType |
  UnmanagedTypePointer PointerType
  deriving (Eq, Ord, Read, Show)

_UnmanagedType = (Core.Name "hydra/ext/csharp/syntax.UnmanagedType")

_UnmanagedType_value = (Core.Name "value")

_UnmanagedType_pointer = (Core.Name "pointer")

newtype VariableReference = 
  VariableReference {
    unVariableReference :: Expression}
  deriving (Eq, Ord, Read, Show)

_VariableReference = (Core.Name "hydra/ext/csharp/syntax.VariableReference")

data Pattern = 
  PatternDeclaration DeclarationPattern |
  PatternConstant Expression |
  PatternVar Designation
  deriving (Eq, Ord, Read, Show)

_Pattern = (Core.Name "hydra/ext/csharp/syntax.Pattern")

_Pattern_declaration = (Core.Name "declaration")

_Pattern_constant = (Core.Name "constant")

_Pattern_var = (Core.Name "var")

data DeclarationPattern = 
  DeclarationPattern {
    declarationPatternType :: Type,
    declarationPatternDesignation :: Designation}
  deriving (Eq, Ord, Read, Show)

_DeclarationPattern = (Core.Name "hydra/ext/csharp/syntax.DeclarationPattern")

_DeclarationPattern_type = (Core.Name "type")

_DeclarationPattern_designation = (Core.Name "designation")

newtype Designation = 
  Designation {
    unDesignation :: Identifier}
  deriving (Eq, Ord, Read, Show)

_Designation = (Core.Name "hydra/ext/csharp/syntax.Designation")

newtype ArgumentList = 
  ArgumentList {
    unArgumentList :: [Argument]}
  deriving (Eq, Ord, Read, Show)

_ArgumentList = (Core.Name "hydra/ext/csharp/syntax.ArgumentList")

data Argument = 
  Argument {
    argumentName :: (Maybe Identifier),
    argumentValue :: ArgumentValue}
  deriving (Eq, Ord, Read, Show)

_Argument = (Core.Name "hydra/ext/csharp/syntax.Argument")

_Argument_name = (Core.Name "name")

_Argument_value = (Core.Name "value")

data ArgumentValue = 
  ArgumentValueExpression Expression |
  ArgumentValueIn VariableReference |
  ArgumentValueRef VariableReference |
  ArgumentValueOut VariableReference
  deriving (Eq, Ord, Read, Show)

_ArgumentValue = (Core.Name "hydra/ext/csharp/syntax.ArgumentValue")

_ArgumentValue_expression = (Core.Name "expression")

_ArgumentValue_in = (Core.Name "in")

_ArgumentValue_ref = (Core.Name "ref")

_ArgumentValue_out = (Core.Name "out")

data PrimaryExpression = 
  PrimaryExpressionNoArray PrimaryNoArrayCreationExpression |
  PrimaryExpressionArray ArrayCreationExpression
  deriving (Eq, Ord, Read, Show)

_PrimaryExpression = (Core.Name "hydra/ext/csharp/syntax.PrimaryExpression")

_PrimaryExpression_noArray = (Core.Name "noArray")

_PrimaryExpression_array = (Core.Name "array")

data PrimaryNoArrayCreationExpression = 
  PrimaryNoArrayCreationExpressionLiteral Literal |
  PrimaryNoArrayCreationExpressionInterpolatedString InterpolatedStringExpression |
  PrimaryNoArrayCreationExpressionSimpleName SimpleName |
  PrimaryNoArrayCreationExpressionParenthesized Expression |
  PrimaryNoArrayCreationExpressionTuple TupleExpression |
  PrimaryNoArrayCreationExpressionMemberAccess MemberAccess |
  PrimaryNoArrayCreationExpressionNullConditionalMemberAccess NullConditionalMemberAccess |
  PrimaryNoArrayCreationExpressionInvocation InvocationExpression |
  PrimaryNoArrayCreationExpressionElementAccess ElementAccess |
  PrimaryNoArrayCreationExpressionNullConditionalElementAccess NullConditionalElementAccess |
  PrimaryNoArrayCreationExpressionThisAccess  |
  PrimaryNoArrayCreationExpressionBaseAccess BaseAccess |
  PrimaryNoArrayCreationExpressionPostIncrement PrimaryExpression |
  PrimaryNoArrayCreationExpressionPostDecrement PrimaryExpression |
  PrimaryNoArrayCreationExpressionObjectCreation ObjectCreationExpression |
  PrimaryNoArrayCreationExpressionDelegateCreation DelegateCreationExpression |
  PrimaryNoArrayCreationExpressionAnonymousObjectCreation (Maybe MemberDeclaratorList) |
  PrimaryNoArrayCreationExpressionTypeof TypeofExpression |
  PrimaryNoArrayCreationExpressionSizeof UnmanagedType |
  PrimaryNoArrayCreationExpressionChecked Expression |
  PrimaryNoArrayCreationExpressionUnchecked Expression |
  PrimaryNoArrayCreationExpressionDefaultValue DefaultValueExpression |
  PrimaryNoArrayCreationExpressionNameof NamedEntity |
  PrimaryNoArrayCreationExpressionAnonymousMethod AnonymousMethodExpression |
  PrimaryNoArrayCreationExpressionPointerMemberAccess PointerMemberAccess |
  PrimaryNoArrayCreationExpressionPointerElementAccess PointerElementAccess |
  PrimaryNoArrayCreationExpressionStackalloc StackallocExpression
  deriving (Eq, Ord, Read, Show)

_PrimaryNoArrayCreationExpression = (Core.Name "hydra/ext/csharp/syntax.PrimaryNoArrayCreationExpression")

_PrimaryNoArrayCreationExpression_literal = (Core.Name "literal")

_PrimaryNoArrayCreationExpression_interpolatedString = (Core.Name "interpolatedString")

_PrimaryNoArrayCreationExpression_simpleName = (Core.Name "simpleName")

_PrimaryNoArrayCreationExpression_parenthesized = (Core.Name "parenthesized")

_PrimaryNoArrayCreationExpression_tuple = (Core.Name "tuple")

_PrimaryNoArrayCreationExpression_memberAccess = (Core.Name "memberAccess")

_PrimaryNoArrayCreationExpression_nullConditionalMemberAccess = (Core.Name "nullConditionalMemberAccess")

_PrimaryNoArrayCreationExpression_invocation = (Core.Name "invocation")

_PrimaryNoArrayCreationExpression_elementAccess = (Core.Name "elementAccess")

_PrimaryNoArrayCreationExpression_nullConditionalElementAccess = (Core.Name "nullConditionalElementAccess")

_PrimaryNoArrayCreationExpression_thisAccess = (Core.Name "thisAccess")

_PrimaryNoArrayCreationExpression_baseAccess = (Core.Name "baseAccess")

_PrimaryNoArrayCreationExpression_postIncrement = (Core.Name "postIncrement")

_PrimaryNoArrayCreationExpression_postDecrement = (Core.Name "postDecrement")

_PrimaryNoArrayCreationExpression_objectCreation = (Core.Name "objectCreation")

_PrimaryNoArrayCreationExpression_delegateCreation = (Core.Name "delegateCreation")

_PrimaryNoArrayCreationExpression_anonymousObjectCreation = (Core.Name "anonymousObjectCreation")

_PrimaryNoArrayCreationExpression_typeof = (Core.Name "typeof")

_PrimaryNoArrayCreationExpression_sizeof = (Core.Name "sizeof")

_PrimaryNoArrayCreationExpression_checked = (Core.Name "checked")

_PrimaryNoArrayCreationExpression_unchecked = (Core.Name "unchecked")

_PrimaryNoArrayCreationExpression_defaultValue = (Core.Name "defaultValue")

_PrimaryNoArrayCreationExpression_nameof = (Core.Name "nameof")

_PrimaryNoArrayCreationExpression_anonymousMethod = (Core.Name "anonymousMethod")

_PrimaryNoArrayCreationExpression_pointerMemberAccess = (Core.Name "pointerMemberAccess")

_PrimaryNoArrayCreationExpression_pointerElementAccess = (Core.Name "pointerElementAccess")

_PrimaryNoArrayCreationExpression_stackalloc = (Core.Name "stackalloc")

data InterpolatedStringExpression = 
  InterpolatedStringExpressionRegular InterpolatedRegularStringExpression |
  InterpolatedStringExpressionVerbatim InterpolatedVerbatimStringExpression
  deriving (Eq, Ord, Read, Show)

_InterpolatedStringExpression = (Core.Name "hydra/ext/csharp/syntax.InterpolatedStringExpression")

_InterpolatedStringExpression_regular = (Core.Name "regular")

_InterpolatedStringExpression_verbatim = (Core.Name "verbatim")

newtype InterpolatedRegularStringExpression = 
  InterpolatedRegularStringExpression {
    unInterpolatedRegularStringExpression :: String}
  deriving (Eq, Ord, Read, Show)

_InterpolatedRegularStringExpression = (Core.Name "hydra/ext/csharp/syntax.InterpolatedRegularStringExpression")

data RegularInterpolation = 
  RegularInterpolation {
    regularInterpolationExpression :: Expression,
    regularInterpolationWidth :: (Maybe Expression),
    regularInterpolationFormat :: (Maybe String)}
  deriving (Eq, Ord, Read, Show)

_RegularInterpolation = (Core.Name "hydra/ext/csharp/syntax.RegularInterpolation")

_RegularInterpolation_expression = (Core.Name "expression")

_RegularInterpolation_width = (Core.Name "width")

_RegularInterpolation_format = (Core.Name "format")

newtype InterpolatedVerbatimStringExpression = 
  InterpolatedVerbatimStringExpression {
    unInterpolatedVerbatimStringExpression :: String}
  deriving (Eq, Ord, Read, Show)

_InterpolatedVerbatimStringExpression = (Core.Name "hydra/ext/csharp/syntax.InterpolatedVerbatimStringExpression")

data VerbatimInterpolation = 
  VerbatimInterpolation {
    verbatimInterpolationExpression :: Expression,
    verbatimInterpolationWidth :: (Maybe ConstantExpression),
    verbatimInterpolationFormat :: (Maybe String)}
  deriving (Eq, Ord, Read, Show)

_VerbatimInterpolation = (Core.Name "hydra/ext/csharp/syntax.VerbatimInterpolation")

_VerbatimInterpolation_expression = (Core.Name "expression")

_VerbatimInterpolation_width = (Core.Name "width")

_VerbatimInterpolation_format = (Core.Name "format")

data SimpleName = 
  SimpleName {
    simpleNameIdentifier :: Identifier,
    simpleNameTypeArguments :: (Maybe TypeArgumentList)}
  deriving (Eq, Ord, Read, Show)

_SimpleName = (Core.Name "hydra/ext/csharp/syntax.SimpleName")

_SimpleName_identifier = (Core.Name "identifier")

_SimpleName_typeArguments = (Core.Name "typeArguments")

data TupleExpression = 
  TupleExpressionElements [TupleElement] |
  TupleExpressionDeconstruction DeconstructionTuple
  deriving (Eq, Ord, Read, Show)

_TupleExpression = (Core.Name "hydra/ext/csharp/syntax.TupleExpression")

_TupleExpression_elements = (Core.Name "elements")

_TupleExpression_deconstruction = (Core.Name "deconstruction")

data TupleElement = 
  TupleElement {
    tupleElementName :: (Maybe Identifier),
    tupleElementExpression :: Expression}
  deriving (Eq, Ord, Read, Show)

_TupleElement = (Core.Name "hydra/ext/csharp/syntax.TupleElement")

_TupleElement_name = (Core.Name "name")

_TupleElement_expression = (Core.Name "expression")

newtype DeconstructionTuple = 
  DeconstructionTuple {
    unDeconstructionTuple :: [DeconstructionElement]}
  deriving (Eq, Ord, Read, Show)

_DeconstructionTuple = (Core.Name "hydra/ext/csharp/syntax.DeconstructionTuple")

data DeconstructionElement = 
  DeconstructionElementTuple DeconstructionTuple |
  DeconstructionElementIdentifier Identifier
  deriving (Eq, Ord, Read, Show)

_DeconstructionElement = (Core.Name "hydra/ext/csharp/syntax.DeconstructionElement")

_DeconstructionElement_tuple = (Core.Name "tuple")

_DeconstructionElement_identifier = (Core.Name "identifier")

data MemberAccess = 
  MemberAccess {
    memberAccessHead :: MemberAccessHead,
    memberAccessIdentifier :: Identifier,
    memberAccessTypeArguments :: (Maybe TypeArgumentList)}
  deriving (Eq, Ord, Read, Show)

_MemberAccess = (Core.Name "hydra/ext/csharp/syntax.MemberAccess")

_MemberAccess_head = (Core.Name "head")

_MemberAccess_identifier = (Core.Name "identifier")

_MemberAccess_typeArguments = (Core.Name "typeArguments")

data MemberAccessHead = 
  MemberAccessHeadPrimary PrimaryExpression |
  MemberAccessHeadPredefined PredefinedType |
  MemberAccessHeadQualifiedAlias QualifiedAliasMember
  deriving (Eq, Ord, Read, Show)

_MemberAccessHead = (Core.Name "hydra/ext/csharp/syntax.MemberAccessHead")

_MemberAccessHead_primary = (Core.Name "primary")

_MemberAccessHead_predefined = (Core.Name "predefined")

_MemberAccessHead_qualifiedAlias = (Core.Name "qualifiedAlias")

data PredefinedType = 
  PredefinedTypeBool  |
  PredefinedTypeByte  |
  PredefinedTypeChar  |
  PredefinedTypeDecimal  |
  PredefinedTypeDouble  |
  PredefinedTypeFloat  |
  PredefinedTypeInt  |
  PredefinedTypeLong  |
  PredefinedTypeObject  |
  PredefinedTypeSbyte  |
  PredefinedTypeShort  |
  PredefinedTypeString  |
  PredefinedTypeUint  |
  PredefinedTypeUlong  |
  PredefinedTypeUshort 
  deriving (Eq, Ord, Read, Show)

_PredefinedType = (Core.Name "hydra/ext/csharp/syntax.PredefinedType")

_PredefinedType_bool = (Core.Name "bool")

_PredefinedType_byte = (Core.Name "byte")

_PredefinedType_char = (Core.Name "char")

_PredefinedType_decimal = (Core.Name "decimal")

_PredefinedType_double = (Core.Name "double")

_PredefinedType_float = (Core.Name "float")

_PredefinedType_int = (Core.Name "int")

_PredefinedType_long = (Core.Name "long")

_PredefinedType_object = (Core.Name "object")

_PredefinedType_sbyte = (Core.Name "sbyte")

_PredefinedType_short = (Core.Name "short")

_PredefinedType_string = (Core.Name "string")

_PredefinedType_uint = (Core.Name "uint")

_PredefinedType_ulong = (Core.Name "ulong")

_PredefinedType_ushort = (Core.Name "ushort")

data NullConditionalMemberAccess = 
  NullConditionalMemberAccess {
    nullConditionalMemberAccessExpression :: PrimaryExpression,
    nullConditionalMemberAccessIdentifier :: Identifier,
    nullConditionalMemberAccessTypeArguments :: (Maybe TypeArgumentList),
    nullConditionalMemberAccessDependentAccess :: [DependentAccess]}
  deriving (Eq, Ord, Read, Show)

_NullConditionalMemberAccess = (Core.Name "hydra/ext/csharp/syntax.NullConditionalMemberAccess")

_NullConditionalMemberAccess_expression = (Core.Name "expression")

_NullConditionalMemberAccess_identifier = (Core.Name "identifier")

_NullConditionalMemberAccess_typeArguments = (Core.Name "typeArguments")

_NullConditionalMemberAccess_dependentAccess = (Core.Name "dependentAccess")

data DependentAccess = 
  DependentAccessMemberAccess DependentAccessForMember |
  DependentAccessElementAccess ArgumentList |
  DependentAccessInvocation (Maybe ArgumentList)
  deriving (Eq, Ord, Read, Show)

_DependentAccess = (Core.Name "hydra/ext/csharp/syntax.DependentAccess")

_DependentAccess_memberAccess = (Core.Name "memberAccess")

_DependentAccess_elementAccess = (Core.Name "elementAccess")

_DependentAccess_invocation = (Core.Name "invocation")

data DependentAccessForMember = 
  DependentAccessForMember {
    dependentAccessForMemberIdentifier :: Identifier,
    dependentAccessForMemberTypeArguments :: (Maybe TypeArgumentList)}
  deriving (Eq, Ord, Read, Show)

_DependentAccessForMember = (Core.Name "hydra/ext/csharp/syntax.DependentAccessForMember")

_DependentAccessForMember_identifier = (Core.Name "identifier")

_DependentAccessForMember_typeArguments = (Core.Name "typeArguments")

data NullConditionalProjectionInitializer = 
  NullConditionalProjectionInitializer {
    nullConditionalProjectionInitializerExpression :: PrimaryExpression,
    nullConditionalProjectionInitializerIdentifier :: Identifier,
    nullConditionalProjectionInitializerTypeArguments :: (Maybe TypeArgumentList)}
  deriving (Eq, Ord, Read, Show)

_NullConditionalProjectionInitializer = (Core.Name "hydra/ext/csharp/syntax.NullConditionalProjectionInitializer")

_NullConditionalProjectionInitializer_expression = (Core.Name "expression")

_NullConditionalProjectionInitializer_identifier = (Core.Name "identifier")

_NullConditionalProjectionInitializer_typeArguments = (Core.Name "typeArguments")

data InvocationExpression = 
  InvocationExpression {
    invocationExpressionExpression :: PrimaryExpression,
    invocationExpressionArguments :: (Maybe ArgumentList)}
  deriving (Eq, Ord, Read, Show)

_InvocationExpression = (Core.Name "hydra/ext/csharp/syntax.InvocationExpression")

_InvocationExpression_expression = (Core.Name "expression")

_InvocationExpression_arguments = (Core.Name "arguments")

data NullConditionalInvocationExpression = 
  NullConditionalInvocationExpression {
    nullConditionalInvocationExpressionHead :: NullConditionalInvocationExpressionHead,
    nullConditionalInvocationExpressionArguments :: (Maybe ArgumentList)}
  deriving (Eq, Ord, Read, Show)

_NullConditionalInvocationExpression = (Core.Name "hydra/ext/csharp/syntax.NullConditionalInvocationExpression")

_NullConditionalInvocationExpression_head = (Core.Name "head")

_NullConditionalInvocationExpression_arguments = (Core.Name "arguments")

data NullConditionalInvocationExpressionHead = 
  NullConditionalInvocationExpressionHeadMember NullConditionalMemberAccess |
  NullConditionalInvocationExpressionHeadElement NullConditionalElementAccess
  deriving (Eq, Ord, Read, Show)

_NullConditionalInvocationExpressionHead = (Core.Name "hydra/ext/csharp/syntax.NullConditionalInvocationExpressionHead")

_NullConditionalInvocationExpressionHead_member = (Core.Name "member")

_NullConditionalInvocationExpressionHead_element = (Core.Name "element")

data ElementAccess = 
  ElementAccess {
    elementAccessExpression :: PrimaryNoArrayCreationExpression,
    elementAccessArguments :: ArgumentList}
  deriving (Eq, Ord, Read, Show)

_ElementAccess = (Core.Name "hydra/ext/csharp/syntax.ElementAccess")

_ElementAccess_expression = (Core.Name "expression")

_ElementAccess_arguments = (Core.Name "arguments")

data NullConditionalElementAccess = 
  NullConditionalElementAccess {
    nullConditionalElementAccessExpression :: PrimaryNoArrayCreationExpression,
    nullConditionalElementAccessArguments :: ArgumentList,
    nullConditionalElementAccessDependentAccess :: [DependentAccess]}
  deriving (Eq, Ord, Read, Show)

_NullConditionalElementAccess = (Core.Name "hydra/ext/csharp/syntax.NullConditionalElementAccess")

_NullConditionalElementAccess_expression = (Core.Name "expression")

_NullConditionalElementAccess_arguments = (Core.Name "arguments")

_NullConditionalElementAccess_dependentAccess = (Core.Name "dependentAccess")

data BaseAccess = 
  BaseAccessIdentifier BaseAccessWithIdentifier |
  BaseAccessArguments ArgumentList
  deriving (Eq, Ord, Read, Show)

_BaseAccess = (Core.Name "hydra/ext/csharp/syntax.BaseAccess")

_BaseAccess_identifier = (Core.Name "identifier")

_BaseAccess_arguments = (Core.Name "arguments")

data BaseAccessWithIdentifier = 
  BaseAccessWithIdentifier {
    baseAccessWithIdentifierIdentifier :: Identifier,
    baseAccessWithIdentifierTypeArguments :: (Maybe TypeArgumentList)}
  deriving (Eq, Ord, Read, Show)

_BaseAccessWithIdentifier = (Core.Name "hydra/ext/csharp/syntax.BaseAccessWithIdentifier")

_BaseAccessWithIdentifier_identifier = (Core.Name "identifier")

_BaseAccessWithIdentifier_typeArguments = (Core.Name "typeArguments")

data ObjectCreationExpression = 
  ObjectCreationExpression {
    objectCreationExpressionType :: Type,
    objectCreationExpressionArguments :: (Maybe ArgumentList),
    objectCreationExpressionInitializer :: (Maybe ObjectOrCollectionInitializer)}
  deriving (Eq, Ord, Read, Show)

_ObjectCreationExpression = (Core.Name "hydra/ext/csharp/syntax.ObjectCreationExpression")

_ObjectCreationExpression_type = (Core.Name "type")

_ObjectCreationExpression_arguments = (Core.Name "arguments")

_ObjectCreationExpression_initializer = (Core.Name "initializer")

data ObjectOrCollectionInitializer = 
  ObjectOrCollectionInitializerObject [MemberInitializer] |
  ObjectOrCollectionInitializerCollection [ElementInitializer]
  deriving (Eq, Ord, Read, Show)

_ObjectOrCollectionInitializer = (Core.Name "hydra/ext/csharp/syntax.ObjectOrCollectionInitializer")

_ObjectOrCollectionInitializer_object = (Core.Name "object")

_ObjectOrCollectionInitializer_collection = (Core.Name "collection")

data MemberInitializer = 
  MemberInitializer {
    memberInitializerTarget :: InitializerTarget,
    memberInitializerValue :: InitializerValue}
  deriving (Eq, Ord, Read, Show)

_MemberInitializer = (Core.Name "hydra/ext/csharp/syntax.MemberInitializer")

_MemberInitializer_target = (Core.Name "target")

_MemberInitializer_value = (Core.Name "value")

data InitializerTarget = 
  InitializerTargetIdentifier Identifier |
  InitializerTargetArguments ArgumentList
  deriving (Eq, Ord, Read, Show)

_InitializerTarget = (Core.Name "hydra/ext/csharp/syntax.InitializerTarget")

_InitializerTarget_identifier = (Core.Name "identifier")

_InitializerTarget_arguments = (Core.Name "arguments")

data InitializerValue = 
  InitializerValueExpression Expression |
  InitializerValueObjectOrCollection ObjectOrCollectionInitializer
  deriving (Eq, Ord, Read, Show)

_InitializerValue = (Core.Name "hydra/ext/csharp/syntax.InitializerValue")

_InitializerValue_expression = (Core.Name "expression")

_InitializerValue_objectOrCollection = (Core.Name "objectOrCollection")

data ElementInitializer = 
  ElementInitializerSingle NonAssignmentExpression |
  ElementInitializerList ExpressionList
  deriving (Eq, Ord, Read, Show)

_ElementInitializer = (Core.Name "hydra/ext/csharp/syntax.ElementInitializer")

_ElementInitializer_single = (Core.Name "single")

_ElementInitializer_list = (Core.Name "list")

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

_ExpressionList = (Core.Name "hydra/ext/csharp/syntax.ExpressionList")

data ArrayCreationExpression = 
  ArrayCreationExpressionNonArrayType NonArrayTypeArrayCreationExpression |
  ArrayCreationExpressionArrayType ArrayTypeArrayCreationExpression |
  ArrayCreationExpressionRankSpecifier RankSpecifierArrayCreationExpression
  deriving (Eq, Ord, Read, Show)

_ArrayCreationExpression = (Core.Name "hydra/ext/csharp/syntax.ArrayCreationExpression")

_ArrayCreationExpression_nonArrayType = (Core.Name "nonArrayType")

_ArrayCreationExpression_arrayType = (Core.Name "arrayType")

_ArrayCreationExpression_rankSpecifier = (Core.Name "rankSpecifier")

data NonArrayTypeArrayCreationExpression = 
  NonArrayTypeArrayCreationExpression {
    nonArrayTypeArrayCreationExpressionType :: NonArrayType,
    nonArrayTypeArrayCreationExpressionExpressions :: ExpressionList,
    nonArrayTypeArrayCreationExpressionRankSpecifiers :: [RankSpecifier],
    nonArrayTypeArrayCreationExpressionInitializer :: (Maybe ArrayInitializer)}
  deriving (Eq, Ord, Read, Show)

_NonArrayTypeArrayCreationExpression = (Core.Name "hydra/ext/csharp/syntax.NonArrayTypeArrayCreationExpression")

_NonArrayTypeArrayCreationExpression_type = (Core.Name "type")

_NonArrayTypeArrayCreationExpression_expressions = (Core.Name "expressions")

_NonArrayTypeArrayCreationExpression_rankSpecifiers = (Core.Name "rankSpecifiers")

_NonArrayTypeArrayCreationExpression_initializer = (Core.Name "initializer")

data ArrayTypeArrayCreationExpression = 
  ArrayTypeArrayCreationExpression {
    arrayTypeArrayCreationExpressionType :: ArrayType,
    arrayTypeArrayCreationExpressionInitializer :: ArrayInitializer}
  deriving (Eq, Ord, Read, Show)

_ArrayTypeArrayCreationExpression = (Core.Name "hydra/ext/csharp/syntax.ArrayTypeArrayCreationExpression")

_ArrayTypeArrayCreationExpression_type = (Core.Name "type")

_ArrayTypeArrayCreationExpression_initializer = (Core.Name "initializer")

data RankSpecifierArrayCreationExpression = 
  RankSpecifierArrayCreationExpression {
    rankSpecifierArrayCreationExpressionRankSpecifier :: RankSpecifier,
    rankSpecifierArrayCreationExpressionInitializer :: ArrayInitializer}
  deriving (Eq, Ord, Read, Show)

_RankSpecifierArrayCreationExpression = (Core.Name "hydra/ext/csharp/syntax.RankSpecifierArrayCreationExpression")

_RankSpecifierArrayCreationExpression_rankSpecifier = (Core.Name "rankSpecifier")

_RankSpecifierArrayCreationExpression_initializer = (Core.Name "initializer")

data DelegateCreationExpression = 
  DelegateCreationExpression {
    delegateCreationExpressionType :: DelegateType,
    delegateCreationExpressionExpression :: Expression}
  deriving (Eq, Ord, Read, Show)

_DelegateCreationExpression = (Core.Name "hydra/ext/csharp/syntax.DelegateCreationExpression")

_DelegateCreationExpression_type = (Core.Name "type")

_DelegateCreationExpression_expression = (Core.Name "expression")

newtype MemberDeclaratorList = 
  MemberDeclaratorList {
    unMemberDeclaratorList :: [MemberDeclarator]}
  deriving (Eq, Ord, Read, Show)

_MemberDeclaratorList = (Core.Name "hydra/ext/csharp/syntax.MemberDeclaratorList")

data MemberDeclarator = 
  MemberDeclaratorName SimpleName |
  MemberDeclaratorMemberAccess MemberAccess |
  MemberDeclaratorNullConditionalProjectionInitializer NullConditionalProjectionInitializer |
  MemberDeclaratorBaseAccess BaseAccess |
  MemberDeclaratorAssignment AssignmentMemberDeclarator
  deriving (Eq, Ord, Read, Show)

_MemberDeclarator = (Core.Name "hydra/ext/csharp/syntax.MemberDeclarator")

_MemberDeclarator_name = (Core.Name "name")

_MemberDeclarator_memberAccess = (Core.Name "memberAccess")

_MemberDeclarator_nullConditionalProjectionInitializer = (Core.Name "nullConditionalProjectionInitializer")

_MemberDeclarator_baseAccess = (Core.Name "baseAccess")

_MemberDeclarator_assignment = (Core.Name "assignment")

data AssignmentMemberDeclarator = 
  AssignmentMemberDeclarator {
    assignmentMemberDeclaratorIdentifier :: Identifier,
    assignmentMemberDeclaratorExpression :: Expression}
  deriving (Eq, Ord, Read, Show)

_AssignmentMemberDeclarator = (Core.Name "hydra/ext/csharp/syntax.AssignmentMemberDeclarator")

_AssignmentMemberDeclarator_identifier = (Core.Name "identifier")

_AssignmentMemberDeclarator_expression = (Core.Name "expression")

data TypeofExpression = 
  TypeofExpressionType Type |
  TypeofExpressionUnboundTypeName UnboundTypeName |
  TypeofExpressionVoid 
  deriving (Eq, Ord, Read, Show)

_TypeofExpression = (Core.Name "hydra/ext/csharp/syntax.TypeofExpression")

_TypeofExpression_type = (Core.Name "type")

_TypeofExpression_unboundTypeName = (Core.Name "unboundTypeName")

_TypeofExpression_void = (Core.Name "void")

newtype UnboundTypeName = 
  UnboundTypeName {
    unUnboundTypeName :: [UnboundTypeNamePart]}
  deriving (Eq, Ord, Read, Show)

_UnboundTypeName = (Core.Name "hydra/ext/csharp/syntax.UnboundTypeName")

data UnboundTypeNamePart = 
  UnboundTypeNamePart {
    unboundTypeNamePartIdentifier :: Identifier,
    unboundTypeNamePartAliased :: Bool,
    unboundTypeNamePartDimension :: (Maybe Int)}
  deriving (Eq, Ord, Read, Show)

_UnboundTypeNamePart = (Core.Name "hydra/ext/csharp/syntax.UnboundTypeNamePart")

_UnboundTypeNamePart_identifier = (Core.Name "identifier")

_UnboundTypeNamePart_aliased = (Core.Name "aliased")

_UnboundTypeNamePart_dimension = (Core.Name "dimension")

data DefaultValueExpression = 
  DefaultValueExpressionExplicitlyTyped Type |
  DefaultValueExpressionDefaultLiteral 
  deriving (Eq, Ord, Read, Show)

_DefaultValueExpression = (Core.Name "hydra/ext/csharp/syntax.DefaultValueExpression")

_DefaultValueExpression_explicitlyTyped = (Core.Name "explicitlyTyped")

_DefaultValueExpression_defaultLiteral = (Core.Name "defaultLiteral")

data StackallocExpression = 
  StackallocExpression {
    stackallocExpressionType :: (Maybe UnmanagedType),
    stackallocExpressionExpression :: (Maybe ConstantExpression),
    stackallocExpressionInitializer :: [Expression]}
  deriving (Eq, Ord, Read, Show)

_StackallocExpression = (Core.Name "hydra/ext/csharp/syntax.StackallocExpression")

_StackallocExpression_type = (Core.Name "type")

_StackallocExpression_expression = (Core.Name "expression")

_StackallocExpression_initializer = (Core.Name "initializer")

data NamedEntity = 
  NamedEntity {
    namedEntityTarget :: NamedEntityTarget,
    namedEntityParts :: [NamedEntityPart]}
  deriving (Eq, Ord, Read, Show)

_NamedEntity = (Core.Name "hydra/ext/csharp/syntax.NamedEntity")

_NamedEntity_target = (Core.Name "target")

_NamedEntity_parts = (Core.Name "parts")

data NamedEntityPart = 
  NamedEntityPart {
    namedEntityPartIdentifier :: Identifier,
    namedEntityPartTypeArguments :: (Maybe TypeArgumentList)}
  deriving (Eq, Ord, Read, Show)

_NamedEntityPart = (Core.Name "hydra/ext/csharp/syntax.NamedEntityPart")

_NamedEntityPart_identifier = (Core.Name "identifier")

_NamedEntityPart_typeArguments = (Core.Name "typeArguments")

data NamedEntityTarget = 
  NamedEntityTargetName SimpleName |
  NamedEntityTargetThis  |
  NamedEntityTargetBase  |
  NamedEntityTargetPredefinedType PredefinedType |
  NamedEntityTargetQualifiedAliasMember QualifiedAliasMember
  deriving (Eq, Ord, Read, Show)

_NamedEntityTarget = (Core.Name "hydra/ext/csharp/syntax.NamedEntityTarget")

_NamedEntityTarget_name = (Core.Name "name")

_NamedEntityTarget_this = (Core.Name "this")

_NamedEntityTarget_base = (Core.Name "base")

_NamedEntityTarget_predefinedType = (Core.Name "predefinedType")

_NamedEntityTarget_qualifiedAliasMember = (Core.Name "qualifiedAliasMember")

data UnaryExpression = 
  UnaryExpressionPrimary PrimaryExpression |
  UnaryExpressionPlus UnaryExpression |
  UnaryExpressionMinus UnaryExpression |
  UnaryExpressionNot UnaryExpression |
  UnaryExpressionBitwiseComplement UnaryExpression |
  UnaryExpressionPreIncrement UnaryExpression |
  UnaryExpressionPreDecrement UnaryExpression |
  UnaryExpressionCast CastExpression |
  UnaryExpressionAwait UnaryExpression |
  UnaryExpressionPointerIndirection UnaryExpression |
  UnaryExpressionAddressOf UnaryExpression
  deriving (Eq, Ord, Read, Show)

_UnaryExpression = (Core.Name "hydra/ext/csharp/syntax.UnaryExpression")

_UnaryExpression_primary = (Core.Name "primary")

_UnaryExpression_plus = (Core.Name "plus")

_UnaryExpression_minus = (Core.Name "minus")

_UnaryExpression_not = (Core.Name "not")

_UnaryExpression_bitwiseComplement = (Core.Name "bitwiseComplement")

_UnaryExpression_preIncrement = (Core.Name "preIncrement")

_UnaryExpression_preDecrement = (Core.Name "preDecrement")

_UnaryExpression_cast = (Core.Name "cast")

_UnaryExpression_await = (Core.Name "await")

_UnaryExpression_pointerIndirection = (Core.Name "pointerIndirection")

_UnaryExpression_addressOf = (Core.Name "addressOf")

data CastExpression = 
  CastExpression {
    castExpressionType :: Type,
    castExpressionExpression :: UnaryExpression}
  deriving (Eq, Ord, Read, Show)

_CastExpression = (Core.Name "hydra/ext/csharp/syntax.CastExpression")

_CastExpression_type = (Core.Name "type")

_CastExpression_expression = (Core.Name "expression")

data MultiplicativeExpression = 
  MultiplicativeExpressionSimple UnaryExpression |
  MultiplicativeExpressionBinary BinaryMultiplicativeExpression
  deriving (Eq, Ord, Read, Show)

_MultiplicativeExpression = (Core.Name "hydra/ext/csharp/syntax.MultiplicativeExpression")

_MultiplicativeExpression_simple = (Core.Name "simple")

_MultiplicativeExpression_binary = (Core.Name "binary")

data BinaryMultiplicativeExpression = 
  BinaryMultiplicativeExpression {
    binaryMultiplicativeExpressionLeft :: MultiplicativeExpression,
    binaryMultiplicativeExpressionOperator :: MultiplicativeOperator,
    binaryMultiplicativeExpressionRight :: UnaryExpression}
  deriving (Eq, Ord, Read, Show)

_BinaryMultiplicativeExpression = (Core.Name "hydra/ext/csharp/syntax.BinaryMultiplicativeExpression")

_BinaryMultiplicativeExpression_left = (Core.Name "left")

_BinaryMultiplicativeExpression_operator = (Core.Name "operator")

_BinaryMultiplicativeExpression_right = (Core.Name "right")

data MultiplicativeOperator = 
  MultiplicativeOperatorTimes  |
  MultiplicativeOperatorDivide  |
  MultiplicativeOperatorModulo 
  deriving (Eq, Ord, Read, Show)

_MultiplicativeOperator = (Core.Name "hydra/ext/csharp/syntax.MultiplicativeOperator")

_MultiplicativeOperator_times = (Core.Name "times")

_MultiplicativeOperator_divide = (Core.Name "divide")

_MultiplicativeOperator_modulo = (Core.Name "modulo")

data AdditiveExpression = 
  AdditiveExpressionSimple MultiplicativeExpression |
  AdditiveExpressionBinary BinaryAdditiveExpression
  deriving (Eq, Ord, Read, Show)

_AdditiveExpression = (Core.Name "hydra/ext/csharp/syntax.AdditiveExpression")

_AdditiveExpression_simple = (Core.Name "simple")

_AdditiveExpression_binary = (Core.Name "binary")

data BinaryAdditiveExpression = 
  BinaryAdditiveExpression {
    binaryAdditiveExpressionLeft :: AdditiveExpression,
    binaryAdditiveExpressionOperator :: AdditiveOperator,
    binaryAdditiveExpressionRight :: MultiplicativeExpression}
  deriving (Eq, Ord, Read, Show)

_BinaryAdditiveExpression = (Core.Name "hydra/ext/csharp/syntax.BinaryAdditiveExpression")

_BinaryAdditiveExpression_left = (Core.Name "left")

_BinaryAdditiveExpression_operator = (Core.Name "operator")

_BinaryAdditiveExpression_right = (Core.Name "right")

data AdditiveOperator = 
  AdditiveOperatorPlus  |
  AdditiveOperatorMinus 
  deriving (Eq, Ord, Read, Show)

_AdditiveOperator = (Core.Name "hydra/ext/csharp/syntax.AdditiveOperator")

_AdditiveOperator_plus = (Core.Name "plus")

_AdditiveOperator_minus = (Core.Name "minus")

data ShiftExpression = 
  ShiftExpressionSimple AdditiveExpression |
  ShiftExpressionBinary BinaryShiftExpression
  deriving (Eq, Ord, Read, Show)

_ShiftExpression = (Core.Name "hydra/ext/csharp/syntax.ShiftExpression")

_ShiftExpression_simple = (Core.Name "simple")

_ShiftExpression_binary = (Core.Name "binary")

data BinaryShiftExpression = 
  BinaryShiftExpression {
    binaryShiftExpressionLeft :: ShiftExpression,
    binaryShiftExpressionOperator :: ShiftOperator,
    binaryShiftExpressionRight :: AdditiveExpression}
  deriving (Eq, Ord, Read, Show)

_BinaryShiftExpression = (Core.Name "hydra/ext/csharp/syntax.BinaryShiftExpression")

_BinaryShiftExpression_left = (Core.Name "left")

_BinaryShiftExpression_operator = (Core.Name "operator")

_BinaryShiftExpression_right = (Core.Name "right")

data ShiftOperator = 
  ShiftOperatorLeft  |
  ShiftOperatorRight 
  deriving (Eq, Ord, Read, Show)

_ShiftOperator = (Core.Name "hydra/ext/csharp/syntax.ShiftOperator")

_ShiftOperator_left = (Core.Name "left")

_ShiftOperator_right = (Core.Name "right")

data RelationalExpression = 
  RelationalExpressionSimple ShiftExpression |
  RelationalExpressionBinary BinaryRelationalExpression |
  RelationalExpressionIsType IsTypeExpression |
  RelationalExpressionIsPattern IsPatternExpression |
  RelationalExpressionAsType AsTypeExpression
  deriving (Eq, Ord, Read, Show)

_RelationalExpression = (Core.Name "hydra/ext/csharp/syntax.RelationalExpression")

_RelationalExpression_simple = (Core.Name "simple")

_RelationalExpression_binary = (Core.Name "binary")

_RelationalExpression_isType = (Core.Name "isType")

_RelationalExpression_isPattern = (Core.Name "isPattern")

_RelationalExpression_asType = (Core.Name "asType")

data BinaryRelationalExpression = 
  BinaryRelationalExpression {
    binaryRelationalExpressionLeft :: RelationalExpression,
    binaryRelationalExpressionOperator :: RelationalOperator,
    binaryRelationalExpressionRight :: ShiftExpression}
  deriving (Eq, Ord, Read, Show)

_BinaryRelationalExpression = (Core.Name "hydra/ext/csharp/syntax.BinaryRelationalExpression")

_BinaryRelationalExpression_left = (Core.Name "left")

_BinaryRelationalExpression_operator = (Core.Name "operator")

_BinaryRelationalExpression_right = (Core.Name "right")

data RelationalOperator = 
  RelationalOperatorLessThan  |
  RelationalOperatorGreaterThan  |
  RelationalOperatorLessThanOrEqual  |
  RelationalOperatorGreaterThanOrEqual 
  deriving (Eq, Ord, Read, Show)

_RelationalOperator = (Core.Name "hydra/ext/csharp/syntax.RelationalOperator")

_RelationalOperator_lessThan = (Core.Name "lessThan")

_RelationalOperator_greaterThan = (Core.Name "greaterThan")

_RelationalOperator_lessThanOrEqual = (Core.Name "lessThanOrEqual")

_RelationalOperator_greaterThanOrEqual = (Core.Name "greaterThanOrEqual")

data IsTypeExpression = 
  IsTypeExpression {
    isTypeExpressionExpression :: RelationalExpression,
    isTypeExpressionType :: Type}
  deriving (Eq, Ord, Read, Show)

_IsTypeExpression = (Core.Name "hydra/ext/csharp/syntax.IsTypeExpression")

_IsTypeExpression_expression = (Core.Name "expression")

_IsTypeExpression_type = (Core.Name "type")

data IsPatternExpression = 
  IsPatternExpression {
    isPatternExpressionExpression :: RelationalExpression,
    isPatternExpressionPattern :: Pattern}
  deriving (Eq, Ord, Read, Show)

_IsPatternExpression = (Core.Name "hydra/ext/csharp/syntax.IsPatternExpression")

_IsPatternExpression_expression = (Core.Name "expression")

_IsPatternExpression_pattern = (Core.Name "pattern")

data AsTypeExpression = 
  AsTypeExpression {
    asTypeExpressionExpression :: RelationalExpression,
    asTypeExpressionType :: Type}
  deriving (Eq, Ord, Read, Show)

_AsTypeExpression = (Core.Name "hydra/ext/csharp/syntax.AsTypeExpression")

_AsTypeExpression_expression = (Core.Name "expression")

_AsTypeExpression_type = (Core.Name "type")

data EqualityExpression = 
  EqualityExpressionSimple RelationalExpression |
  EqualityExpressionBinary BinaryEqualityExpression
  deriving (Eq, Ord, Read, Show)

_EqualityExpression = (Core.Name "hydra/ext/csharp/syntax.EqualityExpression")

_EqualityExpression_simple = (Core.Name "simple")

_EqualityExpression_binary = (Core.Name "binary")

data BinaryEqualityExpression = 
  BinaryEqualityExpression {
    binaryEqualityExpressionLeft :: EqualityExpression,
    binaryEqualityExpressionOperator :: EqualityOperator,
    binaryEqualityExpressionRight :: RelationalExpression}
  deriving (Eq, Ord, Read, Show)

_BinaryEqualityExpression = (Core.Name "hydra/ext/csharp/syntax.BinaryEqualityExpression")

_BinaryEqualityExpression_left = (Core.Name "left")

_BinaryEqualityExpression_operator = (Core.Name "operator")

_BinaryEqualityExpression_right = (Core.Name "right")

data EqualityOperator = 
  EqualityOperatorEqual  |
  EqualityOperatorNotEqual 
  deriving (Eq, Ord, Read, Show)

_EqualityOperator = (Core.Name "hydra/ext/csharp/syntax.EqualityOperator")

_EqualityOperator_equal = (Core.Name "equal")

_EqualityOperator_notEqual = (Core.Name "notEqual")

data AndExpression = 
  AndExpressionSimple EqualityExpression |
  AndExpressionBinary BinaryAndExpression
  deriving (Eq, Ord, Read, Show)

_AndExpression = (Core.Name "hydra/ext/csharp/syntax.AndExpression")

_AndExpression_simple = (Core.Name "simple")

_AndExpression_binary = (Core.Name "binary")

data BinaryAndExpression = 
  BinaryAndExpression {
    binaryAndExpressionLeft :: AndExpression,
    binaryAndExpressionRight :: EqualityExpression}
  deriving (Eq, Ord, Read, Show)

_BinaryAndExpression = (Core.Name "hydra/ext/csharp/syntax.BinaryAndExpression")

_BinaryAndExpression_left = (Core.Name "left")

_BinaryAndExpression_right = (Core.Name "right")

data ExclusiveOrExpression = 
  ExclusiveOrExpressionSimple AndExpression |
  ExclusiveOrExpressionBinary BinaryExclusiveOrExpression
  deriving (Eq, Ord, Read, Show)

_ExclusiveOrExpression = (Core.Name "hydra/ext/csharp/syntax.ExclusiveOrExpression")

_ExclusiveOrExpression_simple = (Core.Name "simple")

_ExclusiveOrExpression_binary = (Core.Name "binary")

data BinaryExclusiveOrExpression = 
  BinaryExclusiveOrExpression {
    binaryExclusiveOrExpressionLeft :: ExclusiveOrExpression,
    binaryExclusiveOrExpressionRight :: AndExpression}
  deriving (Eq, Ord, Read, Show)

_BinaryExclusiveOrExpression = (Core.Name "hydra/ext/csharp/syntax.BinaryExclusiveOrExpression")

_BinaryExclusiveOrExpression_left = (Core.Name "left")

_BinaryExclusiveOrExpression_right = (Core.Name "right")

data InclusiveOrExpression = 
  InclusiveOrExpressionSimple ExclusiveOrExpression |
  InclusiveOrExpressionBinary BinaryInclusiveOrExpression
  deriving (Eq, Ord, Read, Show)

_InclusiveOrExpression = (Core.Name "hydra/ext/csharp/syntax.InclusiveOrExpression")

_InclusiveOrExpression_simple = (Core.Name "simple")

_InclusiveOrExpression_binary = (Core.Name "binary")

data BinaryInclusiveOrExpression = 
  BinaryInclusiveOrExpression {
    binaryInclusiveOrExpressionLeft :: InclusiveOrExpression,
    binaryInclusiveOrExpressionRight :: ExclusiveOrExpression}
  deriving (Eq, Ord, Read, Show)

_BinaryInclusiveOrExpression = (Core.Name "hydra/ext/csharp/syntax.BinaryInclusiveOrExpression")

_BinaryInclusiveOrExpression_left = (Core.Name "left")

_BinaryInclusiveOrExpression_right = (Core.Name "right")

data ConditionalAndExpression = 
  ConditionalAndExpressionSimple InclusiveOrExpression |
  ConditionalAndExpressionBinary BinaryConditionalAndExpression
  deriving (Eq, Ord, Read, Show)

_ConditionalAndExpression = (Core.Name "hydra/ext/csharp/syntax.ConditionalAndExpression")

_ConditionalAndExpression_simple = (Core.Name "simple")

_ConditionalAndExpression_binary = (Core.Name "binary")

data BinaryConditionalAndExpression = 
  BinaryConditionalAndExpression {
    binaryConditionalAndExpressionLeft :: ConditionalAndExpression,
    binaryConditionalAndExpressionRight :: InclusiveOrExpression}
  deriving (Eq, Ord, Read, Show)

_BinaryConditionalAndExpression = (Core.Name "hydra/ext/csharp/syntax.BinaryConditionalAndExpression")

_BinaryConditionalAndExpression_left = (Core.Name "left")

_BinaryConditionalAndExpression_right = (Core.Name "right")

data ConditionalOrExpression = 
  ConditionalOrExpressionSimple ConditionalAndExpression |
  ConditionalOrExpressionBinary BinaryConditionalOrExpression
  deriving (Eq, Ord, Read, Show)

_ConditionalOrExpression = (Core.Name "hydra/ext/csharp/syntax.ConditionalOrExpression")

_ConditionalOrExpression_simple = (Core.Name "simple")

_ConditionalOrExpression_binary = (Core.Name "binary")

data BinaryConditionalOrExpression = 
  BinaryConditionalOrExpression {
    binaryConditionalOrExpressionLeft :: ConditionalOrExpression,
    binaryConditionalOrExpressionRight :: ConditionalAndExpression}
  deriving (Eq, Ord, Read, Show)

_BinaryConditionalOrExpression = (Core.Name "hydra/ext/csharp/syntax.BinaryConditionalOrExpression")

_BinaryConditionalOrExpression_left = (Core.Name "left")

_BinaryConditionalOrExpression_right = (Core.Name "right")

data NullCoalescingExpression = 
  NullCoalescingExpressionSimple ConditionalOrExpression |
  NullCoalescingExpressionBinary BinaryNullCoalescingExpression |
  NullCoalescingExpressionThrow NullCoalescingExpression
  deriving (Eq, Ord, Read, Show)

_NullCoalescingExpression = (Core.Name "hydra/ext/csharp/syntax.NullCoalescingExpression")

_NullCoalescingExpression_simple = (Core.Name "simple")

_NullCoalescingExpression_binary = (Core.Name "binary")

_NullCoalescingExpression_throw = (Core.Name "throw")

data BinaryNullCoalescingExpression = 
  BinaryNullCoalescingExpression {
    binaryNullCoalescingExpressionLeft :: ConditionalOrExpression,
    binaryNullCoalescingExpressionRight :: NullCoalescingExpression}
  deriving (Eq, Ord, Read, Show)

_BinaryNullCoalescingExpression = (Core.Name "hydra/ext/csharp/syntax.BinaryNullCoalescingExpression")

_BinaryNullCoalescingExpression_left = (Core.Name "left")

_BinaryNullCoalescingExpression_right = (Core.Name "right")

data DeclarationExpression = 
  DeclarationExpression {
    declarationExpressionType :: LocalVariableType,
    declarationExpressionIdentifier :: Identifier}
  deriving (Eq, Ord, Read, Show)

_DeclarationExpression = (Core.Name "hydra/ext/csharp/syntax.DeclarationExpression")

_DeclarationExpression_type = (Core.Name "type")

_DeclarationExpression_identifier = (Core.Name "identifier")

data LocalVariableType = 
  LocalVariableTypeType Type |
  LocalVariableTypeVar 
  deriving (Eq, Ord, Read, Show)

_LocalVariableType = (Core.Name "hydra/ext/csharp/syntax.LocalVariableType")

_LocalVariableType_type = (Core.Name "type")

_LocalVariableType_var = (Core.Name "var")

data ConditionalExpression = 
  ConditionalExpressionSimple NullCoalescingExpression |
  ConditionalExpressionSimpleConditional SimpleConditionalExpression |
  ConditionalExpressionRefConditional RefConditionalExpression
  deriving (Eq, Ord, Read, Show)

_ConditionalExpression = (Core.Name "hydra/ext/csharp/syntax.ConditionalExpression")

_ConditionalExpression_simple = (Core.Name "simple")

_ConditionalExpression_simpleConditional = (Core.Name "simpleConditional")

_ConditionalExpression_refConditional = (Core.Name "refConditional")

data SimpleConditionalExpression = 
  SimpleConditionalExpression {
    simpleConditionalExpressionCondition :: NullCoalescingExpression,
    simpleConditionalExpressionTrue :: Expression,
    simpleConditionalExpressionFalse :: Expression}
  deriving (Eq, Ord, Read, Show)

_SimpleConditionalExpression = (Core.Name "hydra/ext/csharp/syntax.SimpleConditionalExpression")

_SimpleConditionalExpression_condition = (Core.Name "condition")

_SimpleConditionalExpression_true = (Core.Name "true")

_SimpleConditionalExpression_false = (Core.Name "false")

data RefConditionalExpression = 
  RefConditionalExpression {
    refConditionalExpressionCondition :: NullCoalescingExpression,
    refConditionalExpressionTrue :: VariableReference,
    refConditionalExpressionFalse :: VariableReference}
  deriving (Eq, Ord, Read, Show)

_RefConditionalExpression = (Core.Name "hydra/ext/csharp/syntax.RefConditionalExpression")

_RefConditionalExpression_condition = (Core.Name "condition")

_RefConditionalExpression_true = (Core.Name "true")

_RefConditionalExpression_false = (Core.Name "false")

data LambdaExpression = 
  LambdaExpression {
    lambdaExpressionAsync :: Bool,
    lambdaExpressionSignature :: AnonymousFunctionSignature,
    lambdaExpressionBody :: AnonymousFunctionBody}
  deriving (Eq, Ord, Read, Show)

_LambdaExpression = (Core.Name "hydra/ext/csharp/syntax.LambdaExpression")

_LambdaExpression_async = (Core.Name "async")

_LambdaExpression_signature = (Core.Name "signature")

_LambdaExpression_body = (Core.Name "body")

data AnonymousMethodExpression = 
  AnonymousMethodExpression {
    anonymousMethodExpressionAsync :: Bool,
    anonymousMethodExpressionSignature :: [ExplicitAnonymousFunctionParameter],
    anonymousMethodExpressionBody :: Block}
  deriving (Eq, Ord, Read, Show)

_AnonymousMethodExpression = (Core.Name "hydra/ext/csharp/syntax.AnonymousMethodExpression")

_AnonymousMethodExpression_async = (Core.Name "async")

_AnonymousMethodExpression_signature = (Core.Name "signature")

_AnonymousMethodExpression_body = (Core.Name "body")

data AnonymousFunctionSignature = 
  AnonymousFunctionSignatureExplicit [ExplicitAnonymousFunctionParameter] |
  AnonymousFunctionSignatureImplicit [Identifier]
  deriving (Eq, Ord, Read, Show)

_AnonymousFunctionSignature = (Core.Name "hydra/ext/csharp/syntax.AnonymousFunctionSignature")

_AnonymousFunctionSignature_explicit = (Core.Name "explicit")

_AnonymousFunctionSignature_implicit = (Core.Name "implicit")

data ExplicitAnonymousFunctionParameter = 
  ExplicitAnonymousFunctionParameter {
    explicitAnonymousFunctionParameterModifier :: (Maybe AnonymousFunctionParameterModifier),
    explicitAnonymousFunctionParameterType :: Type,
    explicitAnonymousFunctionParameterIdentifier :: Identifier}
  deriving (Eq, Ord, Read, Show)

_ExplicitAnonymousFunctionParameter = (Core.Name "hydra/ext/csharp/syntax.ExplicitAnonymousFunctionParameter")

_ExplicitAnonymousFunctionParameter_modifier = (Core.Name "modifier")

_ExplicitAnonymousFunctionParameter_type = (Core.Name "type")

_ExplicitAnonymousFunctionParameter_identifier = (Core.Name "identifier")

data AnonymousFunctionParameterModifier = 
  AnonymousFunctionParameterModifierRef  |
  AnonymousFunctionParameterModifierOut  |
  AnonymousFunctionParameterModifierIn 
  deriving (Eq, Ord, Read, Show)

_AnonymousFunctionParameterModifier = (Core.Name "hydra/ext/csharp/syntax.AnonymousFunctionParameterModifier")

_AnonymousFunctionParameterModifier_ref = (Core.Name "ref")

_AnonymousFunctionParameterModifier_out = (Core.Name "out")

_AnonymousFunctionParameterModifier_in = (Core.Name "in")

data AnonymousFunctionBody = 
  AnonymousFunctionBodyNullConditionalInvocation NullConditionalInvocationExpression |
  AnonymousFunctionBodyExpression Expression |
  AnonymousFunctionBodyRef VariableReference |
  AnonymousFunctionBodyBlock Block
  deriving (Eq, Ord, Read, Show)

_AnonymousFunctionBody = (Core.Name "hydra/ext/csharp/syntax.AnonymousFunctionBody")

_AnonymousFunctionBody_nullConditionalInvocation = (Core.Name "nullConditionalInvocation")

_AnonymousFunctionBody_expression = (Core.Name "expression")

_AnonymousFunctionBody_ref = (Core.Name "ref")

_AnonymousFunctionBody_block = (Core.Name "block")

data QueryExpression = 
  QueryExpression {
    queryExpressionFrom :: FromClause,
    queryExpressionBody :: QueryBody}
  deriving (Eq, Ord, Read, Show)

_QueryExpression = (Core.Name "hydra/ext/csharp/syntax.QueryExpression")

_QueryExpression_from = (Core.Name "from")

_QueryExpression_body = (Core.Name "body")

data FromClause = 
  FromClause {
    fromClauseType :: (Maybe Type),
    fromClauseIdentifier :: Identifier,
    fromClauseIn :: Expression}
  deriving (Eq, Ord, Read, Show)

_FromClause = (Core.Name "hydra/ext/csharp/syntax.FromClause")

_FromClause_type = (Core.Name "type")

_FromClause_identifier = (Core.Name "identifier")

_FromClause_in = (Core.Name "in")

data QueryBody = 
  QueryBody {
    queryBodyClauses :: [QueryBodyClause],
    queryBodySelectOrGroup :: SelectOrGroupClause,
    queryBodyContinuation :: (Maybe QueryContinuation)}
  deriving (Eq, Ord, Read, Show)

_QueryBody = (Core.Name "hydra/ext/csharp/syntax.QueryBody")

_QueryBody_clauses = (Core.Name "clauses")

_QueryBody_selectOrGroup = (Core.Name "selectOrGroup")

_QueryBody_continuation = (Core.Name "continuation")

data QueryBodyClause = 
  QueryBodyClauseFrom FromClause |
  QueryBodyClauseLet LetClause |
  QueryBodyClauseWhere BooleanExpression |
  QueryBodyClauseJoin JoinClause |
  QueryBodyClauseOrderby [Ordering_]
  deriving (Eq, Ord, Read, Show)

_QueryBodyClause = (Core.Name "hydra/ext/csharp/syntax.QueryBodyClause")

_QueryBodyClause_from = (Core.Name "from")

_QueryBodyClause_let = (Core.Name "let")

_QueryBodyClause_where = (Core.Name "where")

_QueryBodyClause_join = (Core.Name "join")

_QueryBodyClause_orderby = (Core.Name "orderby")

data LetClause = 
  LetClause {
    letClauseLeft :: Identifier,
    letClauseRight :: Expression}
  deriving (Eq, Ord, Read, Show)

_LetClause = (Core.Name "hydra/ext/csharp/syntax.LetClause")

_LetClause_left = (Core.Name "left")

_LetClause_right = (Core.Name "right")

data JoinClause = 
  JoinClause {
    joinClauseType :: (Maybe Type),
    joinClauseIdentifier :: Identifier,
    joinClauseIn :: Expression,
    joinClauseOn :: Expression,
    joinClauseEquals :: Expression,
    joinClauseInto :: (Maybe Identifier)}
  deriving (Eq, Ord, Read, Show)

_JoinClause = (Core.Name "hydra/ext/csharp/syntax.JoinClause")

_JoinClause_type = (Core.Name "type")

_JoinClause_identifier = (Core.Name "identifier")

_JoinClause_in = (Core.Name "in")

_JoinClause_on = (Core.Name "on")

_JoinClause_equals = (Core.Name "equals")

_JoinClause_into = (Core.Name "into")

data Ordering_ = 
  Ordering_ {
    orderingExpression :: Expression,
    orderingDirection :: (Maybe OrderingDirection)}
  deriving (Eq, Ord, Read, Show)

_Ordering = (Core.Name "hydra/ext/csharp/syntax.Ordering")

_Ordering_expression = (Core.Name "expression")

_Ordering_direction = (Core.Name "direction")

data OrderingDirection = 
  OrderingDirectionAscending  |
  OrderingDirectionDescending 
  deriving (Eq, Ord, Read, Show)

_OrderingDirection = (Core.Name "hydra/ext/csharp/syntax.OrderingDirection")

_OrderingDirection_ascending = (Core.Name "ascending")

_OrderingDirection_descending = (Core.Name "descending")

data SelectOrGroupClause = 
  SelectOrGroupClauseSelect Expression |
  SelectOrGroupClauseGroup GroupClause
  deriving (Eq, Ord, Read, Show)

_SelectOrGroupClause = (Core.Name "hydra/ext/csharp/syntax.SelectOrGroupClause")

_SelectOrGroupClause_select = (Core.Name "select")

_SelectOrGroupClause_group = (Core.Name "group")

data GroupClause = 
  GroupClause {
    groupClauseGrouped :: Expression,
    groupClauseBy :: Expression}
  deriving (Eq, Ord, Read, Show)

_GroupClause = (Core.Name "hydra/ext/csharp/syntax.GroupClause")

_GroupClause_grouped = (Core.Name "grouped")

_GroupClause_by = (Core.Name "by")

data QueryContinuation = 
  QueryContinuation {
    queryContinuationInto :: Identifier,
    queryContinuationBody :: QueryBody}
  deriving (Eq, Ord, Read, Show)

_QueryContinuation = (Core.Name "hydra/ext/csharp/syntax.QueryContinuation")

_QueryContinuation_into = (Core.Name "into")

_QueryContinuation_body = (Core.Name "body")

data Assignment = 
  Assignment {
    assignmentLeft :: UnaryExpression,
    assignmentOperator :: AssignmentOperator,
    assignmentRight :: Expression}
  deriving (Eq, Ord, Read, Show)

_Assignment = (Core.Name "hydra/ext/csharp/syntax.Assignment")

_Assignment_left = (Core.Name "left")

_Assignment_operator = (Core.Name "operator")

_Assignment_right = (Core.Name "right")

data AssignmentOperator = 
  AssignmentOperatorSimple Bool |
  AssignmentOperatorPlusEquals  |
  AssignmentOperatorMinusEquals  |
  AssignmentOperatorTimesEquals  |
  AssignmentOperatorDivideEquals  |
  AssignmentOperatorModEquals  |
  AssignmentOperatorAndEquals  |
  AssignmentOperatorOrEquals  |
  AssignmentOperatorXorEquals  |
  AssignmentOperatorLeftShiftEquals  |
  AssignmentOperatorRightShiftEquals 
  deriving (Eq, Ord, Read, Show)

_AssignmentOperator = (Core.Name "hydra/ext/csharp/syntax.AssignmentOperator")

_AssignmentOperator_simple = (Core.Name "simple")

_AssignmentOperator_plusEquals = (Core.Name "plusEquals")

_AssignmentOperator_minusEquals = (Core.Name "minusEquals")

_AssignmentOperator_timesEquals = (Core.Name "timesEquals")

_AssignmentOperator_divideEquals = (Core.Name "divideEquals")

_AssignmentOperator_modEquals = (Core.Name "modEquals")

_AssignmentOperator_andEquals = (Core.Name "andEquals")

_AssignmentOperator_orEquals = (Core.Name "orEquals")

_AssignmentOperator_xorEquals = (Core.Name "xorEquals")

_AssignmentOperator_leftShiftEquals = (Core.Name "leftShiftEquals")

_AssignmentOperator_rightShiftEquals = (Core.Name "rightShiftEquals")

data Expression = 
  ExpressionNonAssignment NonAssignmentExpression |
  ExpressionAssignment Assignment
  deriving (Eq, Ord, Read, Show)

_Expression = (Core.Name "hydra/ext/csharp/syntax.Expression")

_Expression_nonAssignment = (Core.Name "nonAssignment")

_Expression_assignment = (Core.Name "assignment")

data NonAssignmentExpression = 
  NonAssignmentExpressionDeclaration DeclarationExpression |
  NonAssignmentExpressionConditional ConditionalExpression |
  NonAssignmentExpressionLambda LambdaExpression |
  NonAssignmentExpressionQuery QueryExpression
  deriving (Eq, Ord, Read, Show)

_NonAssignmentExpression = (Core.Name "hydra/ext/csharp/syntax.NonAssignmentExpression")

_NonAssignmentExpression_declaration = (Core.Name "declaration")

_NonAssignmentExpression_conditional = (Core.Name "conditional")

_NonAssignmentExpression_lambda = (Core.Name "lambda")

_NonAssignmentExpression_query = (Core.Name "query")

newtype ConstantExpression = 
  ConstantExpression {
    unConstantExpression :: Expression}
  deriving (Eq, Ord, Read, Show)

_ConstantExpression = (Core.Name "hydra/ext/csharp/syntax.ConstantExpression")

newtype BooleanExpression = 
  BooleanExpression {
    unBooleanExpression :: Expression}
  deriving (Eq, Ord, Read, Show)

_BooleanExpression = (Core.Name "hydra/ext/csharp/syntax.BooleanExpression")

data Statement = 
  StatementLabeled LabeledStatement |
  StatementDeclaration DeclarationStatement |
  StatementEmbedded EmbeddedStatement
  deriving (Eq, Ord, Read, Show)

_Statement = (Core.Name "hydra/ext/csharp/syntax.Statement")

_Statement_labeled = (Core.Name "labeled")

_Statement_declaration = (Core.Name "declaration")

_Statement_embedded = (Core.Name "embedded")

data EmbeddedStatement = 
  EmbeddedStatementBlock Block |
  EmbeddedStatementEmpty  |
  EmbeddedStatementExpression StatementExpression |
  EmbeddedStatementSelection SelectionStatement |
  EmbeddedStatementIteration IterationStatement |
  EmbeddedStatementJump JumpStatement |
  EmbeddedStatementTry TryStatement |
  EmbeddedStatementChecked Block |
  EmbeddedStatementUnchecked Block |
  EmbeddedStatementLock LockStatement |
  EmbeddedStatementUsing UsingStatement |
  EmbeddedStatementYield YieldStatement |
  EmbeddedStatementUnsafe Block |
  EmbeddedStatementFixed FixedStatement
  deriving (Eq, Ord, Read, Show)

_EmbeddedStatement = (Core.Name "hydra/ext/csharp/syntax.EmbeddedStatement")

_EmbeddedStatement_block = (Core.Name "block")

_EmbeddedStatement_empty = (Core.Name "empty")

_EmbeddedStatement_expression = (Core.Name "expression")

_EmbeddedStatement_selection = (Core.Name "selection")

_EmbeddedStatement_iteration = (Core.Name "iteration")

_EmbeddedStatement_jump = (Core.Name "jump")

_EmbeddedStatement_try = (Core.Name "try")

_EmbeddedStatement_checked = (Core.Name "checked")

_EmbeddedStatement_unchecked = (Core.Name "unchecked")

_EmbeddedStatement_lock = (Core.Name "lock")

_EmbeddedStatement_using = (Core.Name "using")

_EmbeddedStatement_yield = (Core.Name "yield")

_EmbeddedStatement_unsafe = (Core.Name "unsafe")

_EmbeddedStatement_fixed = (Core.Name "fixed")

newtype Block = 
  Block {
    unBlock :: [Statement]}
  deriving (Eq, Ord, Read, Show)

_Block = (Core.Name "hydra/ext/csharp/syntax.Block")

data LabeledStatement = 
  LabeledStatement {
    labeledStatementLabel :: Identifier,
    labeledStatementStatement :: Statement}
  deriving (Eq, Ord, Read, Show)

_LabeledStatement = (Core.Name "hydra/ext/csharp/syntax.LabeledStatement")

_LabeledStatement_label = (Core.Name "label")

_LabeledStatement_statement = (Core.Name "statement")

data DeclarationStatement = 
  DeclarationStatementVariable LocalVariableDeclaration |
  DeclarationStatementConstant LocalConstantDeclaration |
  DeclarationStatementFunction LocalFunctionDeclaration
  deriving (Eq, Ord, Read, Show)

_DeclarationStatement = (Core.Name "hydra/ext/csharp/syntax.DeclarationStatement")

_DeclarationStatement_variable = (Core.Name "variable")

_DeclarationStatement_constant = (Core.Name "constant")

_DeclarationStatement_function = (Core.Name "function")

data LocalVariableDeclaration = 
  LocalVariableDeclarationImplicitlyTyped ImplicitlyTypedLocalVariableDeclaration |
  LocalVariableDeclarationExplicitlyTyped ExplicitlyTypedLocalVariableDeclaration |
  LocalVariableDeclarationRef RefLocalVariableDeclaration
  deriving (Eq, Ord, Read, Show)

_LocalVariableDeclaration = (Core.Name "hydra/ext/csharp/syntax.LocalVariableDeclaration")

_LocalVariableDeclaration_implicitlyTyped = (Core.Name "implicitlyTyped")

_LocalVariableDeclaration_explicitlyTyped = (Core.Name "explicitlyTyped")

_LocalVariableDeclaration_ref = (Core.Name "ref")

data ImplicitlyTypedLocalVariableDeclaration = 
  ImplicitlyTypedLocalVariableDeclarationVar ImplicitlyTypedLocalVariableDeclarator |
  ImplicitlyTypedLocalVariableDeclarationRefVar RefVarImplicitlyTypedLocalVariableDeclaration
  deriving (Eq, Ord, Read, Show)

_ImplicitlyTypedLocalVariableDeclaration = (Core.Name "hydra/ext/csharp/syntax.ImplicitlyTypedLocalVariableDeclaration")

_ImplicitlyTypedLocalVariableDeclaration_var = (Core.Name "var")

_ImplicitlyTypedLocalVariableDeclaration_refVar = (Core.Name "refVar")

data RefVarImplicitlyTypedLocalVariableDeclaration = 
  RefVarImplicitlyTypedLocalVariableDeclaration {
    refVarImplicitlyTypedLocalVariableDeclarationRefKind :: RefKind,
    refVarImplicitlyTypedLocalVariableDeclarationDeclarator :: RefLocalVariableDeclarator}
  deriving (Eq, Ord, Read, Show)

_RefVarImplicitlyTypedLocalVariableDeclaration = (Core.Name "hydra/ext/csharp/syntax.RefVarImplicitlyTypedLocalVariableDeclaration")

_RefVarImplicitlyTypedLocalVariableDeclaration_refKind = (Core.Name "refKind")

_RefVarImplicitlyTypedLocalVariableDeclaration_declarator = (Core.Name "declarator")

data ImplicitlyTypedLocalVariableDeclarator = 
  ImplicitlyTypedLocalVariableDeclarator {
    implicitlyTypedLocalVariableDeclaratorIdentifier :: Identifier,
    implicitlyTypedLocalVariableDeclaratorExpression :: Expression}
  deriving (Eq, Ord, Read, Show)

_ImplicitlyTypedLocalVariableDeclarator = (Core.Name "hydra/ext/csharp/syntax.ImplicitlyTypedLocalVariableDeclarator")

_ImplicitlyTypedLocalVariableDeclarator_identifier = (Core.Name "identifier")

_ImplicitlyTypedLocalVariableDeclarator_expression = (Core.Name "expression")

data ExplicitlyTypedLocalVariableDeclaration = 
  ExplicitlyTypedLocalVariableDeclaration {
    explicitlyTypedLocalVariableDeclarationType :: Type,
    explicitlyTypedLocalVariableDeclarationDeclarators :: [ExplicitlyTypedLocalVariableDeclarator]}
  deriving (Eq, Ord, Read, Show)

_ExplicitlyTypedLocalVariableDeclaration = (Core.Name "hydra/ext/csharp/syntax.ExplicitlyTypedLocalVariableDeclaration")

_ExplicitlyTypedLocalVariableDeclaration_type = (Core.Name "type")

_ExplicitlyTypedLocalVariableDeclaration_declarators = (Core.Name "declarators")

data ExplicitlyTypedLocalVariableDeclarator = 
  ExplicitlyTypedLocalVariableDeclarator {
    explicitlyTypedLocalVariableDeclaratorIdentifier :: Identifier,
    explicitlyTypedLocalVariableDeclaratorInitializer :: (Maybe LocalVariableInitializer)}
  deriving (Eq, Ord, Read, Show)

_ExplicitlyTypedLocalVariableDeclarator = (Core.Name "hydra/ext/csharp/syntax.ExplicitlyTypedLocalVariableDeclarator")

_ExplicitlyTypedLocalVariableDeclarator_identifier = (Core.Name "identifier")

_ExplicitlyTypedLocalVariableDeclarator_initializer = (Core.Name "initializer")

data LocalVariableInitializer = 
  LocalVariableInitializerExpression Expression |
  LocalVariableInitializerInitializer ArrayInitializer
  deriving (Eq, Ord, Read, Show)

_LocalVariableInitializer = (Core.Name "hydra/ext/csharp/syntax.LocalVariableInitializer")

_LocalVariableInitializer_expression = (Core.Name "expression")

_LocalVariableInitializer_initializer = (Core.Name "initializer")

data RefLocalVariableDeclaration = 
  RefLocalVariableDeclaration {
    refLocalVariableDeclarationRefKind :: RefKind,
    refLocalVariableDeclarationType :: Type,
    refLocalVariableDeclarationDeclarators :: [RefLocalVariableDeclarator]}
  deriving (Eq, Ord, Read, Show)

_RefLocalVariableDeclaration = (Core.Name "hydra/ext/csharp/syntax.RefLocalVariableDeclaration")

_RefLocalVariableDeclaration_refKind = (Core.Name "refKind")

_RefLocalVariableDeclaration_type = (Core.Name "type")

_RefLocalVariableDeclaration_declarators = (Core.Name "declarators")

data RefLocalVariableDeclarator = 
  RefLocalVariableDeclarator {
    refLocalVariableDeclaratorLeft :: Identifier,
    refLocalVariableDeclaratorRight :: VariableReference}
  deriving (Eq, Ord, Read, Show)

_RefLocalVariableDeclarator = (Core.Name "hydra/ext/csharp/syntax.RefLocalVariableDeclarator")

_RefLocalVariableDeclarator_left = (Core.Name "left")

_RefLocalVariableDeclarator_right = (Core.Name "right")

data LocalConstantDeclaration = 
  LocalConstantDeclaration {
    localConstantDeclarationType :: Type,
    localConstantDeclarationDeclarators :: [ConstantDeclarator]}
  deriving (Eq, Ord, Read, Show)

_LocalConstantDeclaration = (Core.Name "hydra/ext/csharp/syntax.LocalConstantDeclaration")

_LocalConstantDeclaration_type = (Core.Name "type")

_LocalConstantDeclaration_declarators = (Core.Name "declarators")

data ConstantDeclarator = 
  ConstantDeclarator {
    constantDeclaratorIdentifier :: Identifier,
    constantDeclaratorExpression :: ConstantExpression}
  deriving (Eq, Ord, Read, Show)

_ConstantDeclarator = (Core.Name "hydra/ext/csharp/syntax.ConstantDeclarator")

_ConstantDeclarator_identifier = (Core.Name "identifier")

_ConstantDeclarator_expression = (Core.Name "expression")

data LocalFunctionDeclaration = 
  LocalFunctionDeclarationStandard StandardLocalFunctionDeclaration |
  LocalFunctionDeclarationRef RefLocalFunctionDeclaration
  deriving (Eq, Ord, Read, Show)

_LocalFunctionDeclaration = (Core.Name "hydra/ext/csharp/syntax.LocalFunctionDeclaration")

_LocalFunctionDeclaration_standard = (Core.Name "standard")

_LocalFunctionDeclaration_ref = (Core.Name "ref")

data StandardLocalFunctionDeclaration = 
  StandardLocalFunctionDeclaration {
    standardLocalFunctionDeclarationModifiers :: [LocalFunctionModifier],
    standardLocalFunctionDeclarationReturnType :: ReturnType,
    standardLocalFunctionDeclarationHeader :: LocalFunctionHeader,
    standardLocalFunctionDeclarationBody :: LocalFunctionBody}
  deriving (Eq, Ord, Read, Show)

_StandardLocalFunctionDeclaration = (Core.Name "hydra/ext/csharp/syntax.StandardLocalFunctionDeclaration")

_StandardLocalFunctionDeclaration_modifiers = (Core.Name "modifiers")

_StandardLocalFunctionDeclaration_returnType = (Core.Name "returnType")

_StandardLocalFunctionDeclaration_header = (Core.Name "header")

_StandardLocalFunctionDeclaration_body = (Core.Name "body")

data RefLocalFunctionDeclaration = 
  RefLocalFunctionDeclaration {
    refLocalFunctionDeclarationModifiers :: [RefLocalFunctionModifier],
    refLocalFunctionDeclarationRefKind :: RefKind,
    refLocalFunctionDeclarationReturnType :: Type,
    refLocalFunctionDeclarationHeader :: LocalFunctionHeader,
    refLocalFunctionDeclarationBody :: RefLocalFunctionBody}
  deriving (Eq, Ord, Read, Show)

_RefLocalFunctionDeclaration = (Core.Name "hydra/ext/csharp/syntax.RefLocalFunctionDeclaration")

_RefLocalFunctionDeclaration_modifiers = (Core.Name "modifiers")

_RefLocalFunctionDeclaration_refKind = (Core.Name "refKind")

_RefLocalFunctionDeclaration_returnType = (Core.Name "returnType")

_RefLocalFunctionDeclaration_header = (Core.Name "header")

_RefLocalFunctionDeclaration_body = (Core.Name "body")

data LocalFunctionHeader = 
  LocalFunctionHeader {
    localFunctionHeaderIdentifier :: Identifier,
    localFunctionHeaderTypeParameters :: (Maybe TypeParameterList),
    localFunctionHeaderParameters :: FormalParameterList,
    localFunctionHeaderConstraints :: [TypeParameterConstraintsClause]}
  deriving (Eq, Ord, Read, Show)

_LocalFunctionHeader = (Core.Name "hydra/ext/csharp/syntax.LocalFunctionHeader")

_LocalFunctionHeader_identifier = (Core.Name "identifier")

_LocalFunctionHeader_typeParameters = (Core.Name "typeParameters")

_LocalFunctionHeader_parameters = (Core.Name "parameters")

_LocalFunctionHeader_constraints = (Core.Name "constraints")

data LocalFunctionModifier = 
  LocalFunctionModifierRef RefLocalFunctionModifier |
  LocalFunctionModifierAsync 
  deriving (Eq, Ord, Read, Show)

_LocalFunctionModifier = (Core.Name "hydra/ext/csharp/syntax.LocalFunctionModifier")

_LocalFunctionModifier_ref = (Core.Name "ref")

_LocalFunctionModifier_async = (Core.Name "async")

data RefLocalFunctionModifier = 
  RefLocalFunctionModifierStatic  |
  RefLocalFunctionModifierUnsafe 
  deriving (Eq, Ord, Read, Show)

_RefLocalFunctionModifier = (Core.Name "hydra/ext/csharp/syntax.RefLocalFunctionModifier")

_RefLocalFunctionModifier_static = (Core.Name "static")

_RefLocalFunctionModifier_unsafe = (Core.Name "unsafe")

data LocalFunctionBody = 
  LocalFunctionBodyBlock Block |
  LocalFunctionBodyNullConditionalInvocation NullConditionalInvocationExpression |
  LocalFunctionBodyExpression Expression
  deriving (Eq, Ord, Read, Show)

_LocalFunctionBody = (Core.Name "hydra/ext/csharp/syntax.LocalFunctionBody")

_LocalFunctionBody_block = (Core.Name "block")

_LocalFunctionBody_nullConditionalInvocation = (Core.Name "nullConditionalInvocation")

_LocalFunctionBody_expression = (Core.Name "expression")

data RefLocalFunctionBody = 
  RefLocalFunctionBodyBlock Block |
  RefLocalFunctionBodyRef VariableReference
  deriving (Eq, Ord, Read, Show)

_RefLocalFunctionBody = (Core.Name "hydra/ext/csharp/syntax.RefLocalFunctionBody")

_RefLocalFunctionBody_block = (Core.Name "block")

_RefLocalFunctionBody_ref = (Core.Name "ref")

data StatementExpression = 
  StatementExpressionNullConditionalInvocation NullConditionalInvocationExpression |
  StatementExpressionInvocation InvocationExpression |
  StatementExpressionObjectCreation ObjectCreationExpression |
  StatementExpressionAssignment Assignment |
  StatementExpressionPostIncrement PrimaryExpression |
  StatementExpressionPostDecrement PrimaryExpression |
  StatementExpressionPreIncrement UnaryExpression |
  StatementExpressionPreDecrement UnaryExpression |
  StatementExpressionAwait UnaryExpression
  deriving (Eq, Ord, Read, Show)

_StatementExpression = (Core.Name "hydra/ext/csharp/syntax.StatementExpression")

_StatementExpression_nullConditionalInvocation = (Core.Name "nullConditionalInvocation")

_StatementExpression_invocation = (Core.Name "invocation")

_StatementExpression_objectCreation = (Core.Name "objectCreation")

_StatementExpression_assignment = (Core.Name "assignment")

_StatementExpression_postIncrement = (Core.Name "postIncrement")

_StatementExpression_postDecrement = (Core.Name "postDecrement")

_StatementExpression_preIncrement = (Core.Name "preIncrement")

_StatementExpression_preDecrement = (Core.Name "preDecrement")

_StatementExpression_await = (Core.Name "await")

data SelectionStatement = 
  SelectionStatementIf IfStatement |
  SelectionStatementSwitch SwitchStatement
  deriving (Eq, Ord, Read, Show)

_SelectionStatement = (Core.Name "hydra/ext/csharp/syntax.SelectionStatement")

_SelectionStatement_if = (Core.Name "if")

_SelectionStatement_switch = (Core.Name "switch")

data IfStatement = 
  IfStatement {
    ifStatementCondition :: BooleanExpression,
    ifStatementIfBranch :: EmbeddedStatement,
    ifStatementElseBranch :: EmbeddedStatement}
  deriving (Eq, Ord, Read, Show)

_IfStatement = (Core.Name "hydra/ext/csharp/syntax.IfStatement")

_IfStatement_condition = (Core.Name "condition")

_IfStatement_ifBranch = (Core.Name "ifBranch")

_IfStatement_elseBranch = (Core.Name "elseBranch")

data SwitchStatement = 
  SwitchStatement {
    switchStatementExpression :: Expression,
    switchStatementBranches :: [SwitchSection]}
  deriving (Eq, Ord, Read, Show)

_SwitchStatement = (Core.Name "hydra/ext/csharp/syntax.SwitchStatement")

_SwitchStatement_expression = (Core.Name "expression")

_SwitchStatement_branches = (Core.Name "branches")

data SwitchSection = 
  SwitchSection {
    switchSectionLabels :: [SwitchLabel],
    switchSectionStatements :: [Statement]}
  deriving (Eq, Ord, Read, Show)

_SwitchSection = (Core.Name "hydra/ext/csharp/syntax.SwitchSection")

_SwitchSection_labels = (Core.Name "labels")

_SwitchSection_statements = (Core.Name "statements")

data SwitchLabel = 
  SwitchLabelBranch SwitchBranch |
  SwitchLabelDefault 
  deriving (Eq, Ord, Read, Show)

_SwitchLabel = (Core.Name "hydra/ext/csharp/syntax.SwitchLabel")

_SwitchLabel_branch = (Core.Name "branch")

_SwitchLabel_default = (Core.Name "default")

data SwitchBranch = 
  SwitchBranch {
    switchBranchPattern :: Pattern,
    switchBranchGuard :: (Maybe Expression)}
  deriving (Eq, Ord, Read, Show)

_SwitchBranch = (Core.Name "hydra/ext/csharp/syntax.SwitchBranch")

_SwitchBranch_pattern = (Core.Name "pattern")

_SwitchBranch_guard = (Core.Name "guard")

data IterationStatement = 
  IterationStatementWhile WhileStatement |
  IterationStatementDo DoStatement |
  IterationStatementFor ForStatement |
  IterationStatementForeach ForeachStatement
  deriving (Eq, Ord, Read, Show)

_IterationStatement = (Core.Name "hydra/ext/csharp/syntax.IterationStatement")

_IterationStatement_while = (Core.Name "while")

_IterationStatement_do = (Core.Name "do")

_IterationStatement_for = (Core.Name "for")

_IterationStatement_foreach = (Core.Name "foreach")

data WhileStatement = 
  WhileStatement {
    whileStatementCondition :: BooleanExpression,
    whileStatementBody :: EmbeddedStatement}
  deriving (Eq, Ord, Read, Show)

_WhileStatement = (Core.Name "hydra/ext/csharp/syntax.WhileStatement")

_WhileStatement_condition = (Core.Name "condition")

_WhileStatement_body = (Core.Name "body")

data DoStatement = 
  DoStatement {
    doStatementBody :: EmbeddedStatement,
    doStatementWhile :: BooleanExpression}
  deriving (Eq, Ord, Read, Show)

_DoStatement = (Core.Name "hydra/ext/csharp/syntax.DoStatement")

_DoStatement_body = (Core.Name "body")

_DoStatement_while = (Core.Name "while")

data ForStatement = 
  ForStatement {
    forStatementInitializer :: (Maybe ForInitializer),
    forStatementCondition :: (Maybe BooleanExpression),
    forStatementIterator :: (Maybe StatementExpressionList),
    forStatementBody :: EmbeddedStatement}
  deriving (Eq, Ord, Read, Show)

_ForStatement = (Core.Name "hydra/ext/csharp/syntax.ForStatement")

_ForStatement_initializer = (Core.Name "initializer")

_ForStatement_condition = (Core.Name "condition")

_ForStatement_iterator = (Core.Name "iterator")

_ForStatement_body = (Core.Name "body")

data ForInitializer = 
  ForInitializerVariable LocalVariableDeclaration |
  ForInitializerStatements StatementExpressionList
  deriving (Eq, Ord, Read, Show)

_ForInitializer = (Core.Name "hydra/ext/csharp/syntax.ForInitializer")

_ForInitializer_variable = (Core.Name "variable")

_ForInitializer_statements = (Core.Name "statements")

newtype StatementExpressionList = 
  StatementExpressionList {
    unStatementExpressionList :: [StatementExpression]}
  deriving (Eq, Ord, Read, Show)

_StatementExpressionList = (Core.Name "hydra/ext/csharp/syntax.StatementExpressionList")

data ForeachStatement = 
  ForeachStatement {
    foreachStatementKind :: (Maybe RefKind),
    foreachStatementType :: LocalVariableType,
    foreachStatementIdentifier :: Identifier,
    foreachStatementExpression :: Expression,
    foreachStatementBody :: EmbeddedStatement}
  deriving (Eq, Ord, Read, Show)

_ForeachStatement = (Core.Name "hydra/ext/csharp/syntax.ForeachStatement")

_ForeachStatement_kind = (Core.Name "kind")

_ForeachStatement_type = (Core.Name "type")

_ForeachStatement_identifier = (Core.Name "identifier")

_ForeachStatement_expression = (Core.Name "expression")

_ForeachStatement_body = (Core.Name "body")

data JumpStatement = 
  JumpStatementBreak  |
  JumpStatementContinue  |
  JumpStatementGoto GotoStatement |
  JumpStatementReturn ReturnStatement |
  JumpStatementThrow (Maybe Expression)
  deriving (Eq, Ord, Read, Show)

_JumpStatement = (Core.Name "hydra/ext/csharp/syntax.JumpStatement")

_JumpStatement_break = (Core.Name "break")

_JumpStatement_continue = (Core.Name "continue")

_JumpStatement_goto = (Core.Name "goto")

_JumpStatement_return = (Core.Name "return")

_JumpStatement_throw = (Core.Name "throw")

data GotoStatement = 
  GotoStatementIdentifier Identifier |
  GotoStatementCase ConstantExpression |
  GotoStatementDefault 
  deriving (Eq, Ord, Read, Show)

_GotoStatement = (Core.Name "hydra/ext/csharp/syntax.GotoStatement")

_GotoStatement_identifier = (Core.Name "identifier")

_GotoStatement_case = (Core.Name "case")

_GotoStatement_default = (Core.Name "default")

data ReturnStatement = 
  ReturnStatementSimple  |
  ReturnStatementValue Expression |
  ReturnStatementRef VariableReference
  deriving (Eq, Ord, Read, Show)

_ReturnStatement = (Core.Name "hydra/ext/csharp/syntax.ReturnStatement")

_ReturnStatement_simple = (Core.Name "simple")

_ReturnStatement_value = (Core.Name "value")

_ReturnStatement_ref = (Core.Name "ref")

data TryStatement = 
  TryStatement {
    tryStatementBody :: Block,
    tryStatementCatches :: CatchClauses,
    tryStatementFinally :: (Maybe Block)}
  deriving (Eq, Ord, Read, Show)

_TryStatement = (Core.Name "hydra/ext/csharp/syntax.TryStatement")

_TryStatement_body = (Core.Name "body")

_TryStatement_catches = (Core.Name "catches")

_TryStatement_finally = (Core.Name "finally")

data CatchClauses = 
  CatchClausesSpecific [SpecificCatchClause] |
  CatchClausesGeneral Block
  deriving (Eq, Ord, Read, Show)

_CatchClauses = (Core.Name "hydra/ext/csharp/syntax.CatchClauses")

_CatchClauses_specific = (Core.Name "specific")

_CatchClauses_general = (Core.Name "general")

data SpecificCatchClause = 
  SpecificCatchClause {
    specificCatchClauseSpecifier :: (Maybe ExceptionSpecifier),
    specificCatchClauseFilter :: (Maybe BooleanExpression),
    specificCatchClauseBody :: Block}
  deriving (Eq, Ord, Read, Show)

_SpecificCatchClause = (Core.Name "hydra/ext/csharp/syntax.SpecificCatchClause")

_SpecificCatchClause_specifier = (Core.Name "specifier")

_SpecificCatchClause_filter = (Core.Name "filter")

_SpecificCatchClause_body = (Core.Name "body")

data ExceptionSpecifier = 
  ExceptionSpecifier {
    exceptionSpecifierType :: Type,
    exceptionSpecifierIdentifier :: (Maybe Identifier)}
  deriving (Eq, Ord, Read, Show)

_ExceptionSpecifier = (Core.Name "hydra/ext/csharp/syntax.ExceptionSpecifier")

_ExceptionSpecifier_type = (Core.Name "type")

_ExceptionSpecifier_identifier = (Core.Name "identifier")

data LockStatement = 
  LockStatement {
    lockStatementExpression :: Expression,
    lockStatementBody :: EmbeddedStatement}
  deriving (Eq, Ord, Read, Show)

_LockStatement = (Core.Name "hydra/ext/csharp/syntax.LockStatement")

_LockStatement_expression = (Core.Name "expression")

_LockStatement_body = (Core.Name "body")

data UsingStatement = 
  UsingStatement {
    usingStatementAcquisition :: ResourceAcquisition,
    usingStatementBody :: EmbeddedStatement}
  deriving (Eq, Ord, Read, Show)

_UsingStatement = (Core.Name "hydra/ext/csharp/syntax.UsingStatement")

_UsingStatement_acquisition = (Core.Name "acquisition")

_UsingStatement_body = (Core.Name "body")

data ResourceAcquisition = 
  ResourceAcquisitionLocal LocalVariableDeclaration |
  ResourceAcquisitionExpression Expression
  deriving (Eq, Ord, Read, Show)

_ResourceAcquisition = (Core.Name "hydra/ext/csharp/syntax.ResourceAcquisition")

_ResourceAcquisition_local = (Core.Name "local")

_ResourceAcquisition_expression = (Core.Name "expression")

data YieldStatement = 
  YieldStatementReturn Expression |
  YieldStatementBreak 
  deriving (Eq, Ord, Read, Show)

_YieldStatement = (Core.Name "hydra/ext/csharp/syntax.YieldStatement")

_YieldStatement_return = (Core.Name "return")

_YieldStatement_break = (Core.Name "break")

data CompilationUnit = 
  CompilationUnit {
    compilationUnitExterns :: [Identifier],
    compilationUnitUsings :: [UsingDirective],
    compilationUnitAttributes :: [GlobalAttributeSection],
    compilationUnitMembers :: [NamespaceMemberDeclaration]}
  deriving (Eq, Ord, Read, Show)

_CompilationUnit = (Core.Name "hydra/ext/csharp/syntax.CompilationUnit")

_CompilationUnit_externs = (Core.Name "externs")

_CompilationUnit_usings = (Core.Name "usings")

_CompilationUnit_attributes = (Core.Name "attributes")

_CompilationUnit_members = (Core.Name "members")

data NamespaceDeclaration = 
  NamespaceDeclaration {
    namespaceDeclarationName :: [Identifier],
    namespaceDeclarationBody :: NamespaceBody}
  deriving (Eq, Ord, Read, Show)

_NamespaceDeclaration = (Core.Name "hydra/ext/csharp/syntax.NamespaceDeclaration")

_NamespaceDeclaration_name = (Core.Name "name")

_NamespaceDeclaration_body = (Core.Name "body")

data NamespaceBody = 
  NamespaceBody {
    namespaceBodyExterns :: [Identifier],
    namespaceBodyUsings :: [UsingDirective],
    namespaceBodyMembers :: [NamespaceMemberDeclaration]}
  deriving (Eq, Ord, Read, Show)

_NamespaceBody = (Core.Name "hydra/ext/csharp/syntax.NamespaceBody")

_NamespaceBody_externs = (Core.Name "externs")

_NamespaceBody_usings = (Core.Name "usings")

_NamespaceBody_members = (Core.Name "members")

data UsingDirective = 
  UsingDirectiveAlias UsingAliasDirective |
  UsingDirectiveNamespace NamespaceName |
  UsingDirectiveStatic TypeName
  deriving (Eq, Ord, Read, Show)

_UsingDirective = (Core.Name "hydra/ext/csharp/syntax.UsingDirective")

_UsingDirective_alias = (Core.Name "alias")

_UsingDirective_namespace = (Core.Name "namespace")

_UsingDirective_static = (Core.Name "static")

data UsingAliasDirective = 
  UsingAliasDirective {
    usingAliasDirectiveAlias :: Identifier,
    usingAliasDirectiveName :: NamespaceOrTypeName}
  deriving (Eq, Ord, Read, Show)

_UsingAliasDirective = (Core.Name "hydra/ext/csharp/syntax.UsingAliasDirective")

_UsingAliasDirective_alias = (Core.Name "alias")

_UsingAliasDirective_name = (Core.Name "name")

data NamespaceMemberDeclaration = 
  NamespaceMemberDeclarationNamespace NamespaceDeclaration |
  NamespaceMemberDeclarationType TypeDeclaration
  deriving (Eq, Ord, Read, Show)

_NamespaceMemberDeclaration = (Core.Name "hydra/ext/csharp/syntax.NamespaceMemberDeclaration")

_NamespaceMemberDeclaration_namespace = (Core.Name "namespace")

_NamespaceMemberDeclaration_type = (Core.Name "type")

data TypeDeclaration = 
  TypeDeclarationClass ClassDeclaration |
  TypeDeclarationStruct StructDeclaration |
  TypeDeclarationInterface InterfaceDeclaration |
  TypeDeclarationEnum EnumDeclaration |
  TypeDeclarationDelegate DelegateDeclaration
  deriving (Eq, Ord, Read, Show)

_TypeDeclaration = (Core.Name "hydra/ext/csharp/syntax.TypeDeclaration")

_TypeDeclaration_class = (Core.Name "class")

_TypeDeclaration_struct = (Core.Name "struct")

_TypeDeclaration_interface = (Core.Name "interface")

_TypeDeclaration_enum = (Core.Name "enum")

_TypeDeclaration_delegate = (Core.Name "delegate")

data QualifiedAliasMember = 
  QualifiedAliasMember {
    qualifiedAliasMemberAlias :: Identifier,
    qualifiedAliasMemberMember :: Identifier,
    qualifiedAliasMemberArguments :: (Maybe TypeArgumentList)}
  deriving (Eq, Ord, Read, Show)

_QualifiedAliasMember = (Core.Name "hydra/ext/csharp/syntax.QualifiedAliasMember")

_QualifiedAliasMember_alias = (Core.Name "alias")

_QualifiedAliasMember_member = (Core.Name "member")

_QualifiedAliasMember_arguments = (Core.Name "arguments")

data ClassDeclaration = 
  ClassDeclaration {
    classDeclarationAttributes :: (Maybe Attributes),
    classDeclarationModifiers :: [ClassModifier],
    classDeclarationPartial :: (),
    classDeclarationName :: Identifier,
    classDeclarationParameters :: (Maybe TypeParameterList),
    classDeclarationBase :: (Maybe ClassBase),
    classDeclarationConstraints :: [TypeParameterConstraintsClause],
    classDeclarationBody :: ClassBody}
  deriving (Eq, Ord, Read, Show)

_ClassDeclaration = (Core.Name "hydra/ext/csharp/syntax.ClassDeclaration")

_ClassDeclaration_attributes = (Core.Name "attributes")

_ClassDeclaration_modifiers = (Core.Name "modifiers")

_ClassDeclaration_partial = (Core.Name "partial")

_ClassDeclaration_name = (Core.Name "name")

_ClassDeclaration_parameters = (Core.Name "parameters")

_ClassDeclaration_base = (Core.Name "base")

_ClassDeclaration_constraints = (Core.Name "constraints")

_ClassDeclaration_body = (Core.Name "body")

data ClassModifier = 
  ClassModifierNew  |
  ClassModifierPublic  |
  ClassModifierProtected  |
  ClassModifierInternal  |
  ClassModifierPrivate  |
  ClassModifierAbstract  |
  ClassModifierSealed  |
  ClassModifierStatic  |
  ClassModifierUnsafe 
  deriving (Eq, Ord, Read, Show)

_ClassModifier = (Core.Name "hydra/ext/csharp/syntax.ClassModifier")

_ClassModifier_new = (Core.Name "new")

_ClassModifier_public = (Core.Name "public")

_ClassModifier_protected = (Core.Name "protected")

_ClassModifier_internal = (Core.Name "internal")

_ClassModifier_private = (Core.Name "private")

_ClassModifier_abstract = (Core.Name "abstract")

_ClassModifier_sealed = (Core.Name "sealed")

_ClassModifier_static = (Core.Name "static")

_ClassModifier_unsafe = (Core.Name "unsafe")

newtype TypeParameterList = 
  TypeParameterList {
    unTypeParameterList :: [TypeParameterPart]}
  deriving (Eq, Ord, Read, Show)

_TypeParameterList = (Core.Name "hydra/ext/csharp/syntax.TypeParameterList")

data TypeParameterPart = 
  TypeParameterPart {
    typeParameterPartAttributes :: (Maybe Attributes),
    typeParameterPartName :: TypeParameter}
  deriving (Eq, Ord, Read, Show)

_TypeParameterPart = (Core.Name "hydra/ext/csharp/syntax.TypeParameterPart")

_TypeParameterPart_attributes = (Core.Name "attributes")

_TypeParameterPart_name = (Core.Name "name")

data ClassBase = 
  ClassBaseClass (Maybe ClassType) |
  ClassBaseInterfaces [InterfaceType]
  deriving (Eq, Ord, Read, Show)

_ClassBase = (Core.Name "hydra/ext/csharp/syntax.ClassBase")

_ClassBase_class = (Core.Name "class")

_ClassBase_interfaces = (Core.Name "interfaces")

data TypeParameterConstraintsClause = 
  TypeParameterConstraintsClause {
    typeParameterConstraintsClauseParameter :: TypeParameter,
    typeParameterConstraintsClauseConstraints :: [TypeParameterConstraints]}
  deriving (Eq, Ord, Read, Show)

_TypeParameterConstraintsClause = (Core.Name "hydra/ext/csharp/syntax.TypeParameterConstraintsClause")

_TypeParameterConstraintsClause_parameter = (Core.Name "parameter")

_TypeParameterConstraintsClause_constraints = (Core.Name "constraints")

data TypeParameterConstraints = 
  TypeParameterConstraints {
    typeParameterConstraintsPrimary :: (Maybe PrimaryConstraint),
    typeParameterConstraintsSecondary :: (Maybe SecondaryConstraints),
    typeParameterConstraintsConstructor :: Bool}
  deriving (Eq, Ord, Read, Show)

_TypeParameterConstraints = (Core.Name "hydra/ext/csharp/syntax.TypeParameterConstraints")

_TypeParameterConstraints_primary = (Core.Name "primary")

_TypeParameterConstraints_secondary = (Core.Name "secondary")

_TypeParameterConstraints_constructor = (Core.Name "constructor")

data PrimaryConstraint = 
  PrimaryConstraintClassType ClassType |
  PrimaryConstraintClass  |
  PrimaryConstraintStruct  |
  PrimaryConstraintUnmanaged 
  deriving (Eq, Ord, Read, Show)

_PrimaryConstraint = (Core.Name "hydra/ext/csharp/syntax.PrimaryConstraint")

_PrimaryConstraint_classType = (Core.Name "classType")

_PrimaryConstraint_class = (Core.Name "class")

_PrimaryConstraint_struct = (Core.Name "struct")

_PrimaryConstraint_unmanaged = (Core.Name "unmanaged")

newtype SecondaryConstraints = 
  SecondaryConstraints {
    unSecondaryConstraints :: [SecondaryConstraint]}
  deriving (Eq, Ord, Read, Show)

_SecondaryConstraints = (Core.Name "hydra/ext/csharp/syntax.SecondaryConstraints")

data SecondaryConstraint = 
  SecondaryConstraintInterface InterfaceType |
  SecondaryConstraintParameter TypeParameter
  deriving (Eq, Ord, Read, Show)

_SecondaryConstraint = (Core.Name "hydra/ext/csharp/syntax.SecondaryConstraint")

_SecondaryConstraint_interface = (Core.Name "interface")

_SecondaryConstraint_parameter = (Core.Name "parameter")

newtype ClassBody = 
  ClassBody {
    unClassBody :: [ClassMemberDeclaration]}
  deriving (Eq, Ord, Read, Show)

_ClassBody = (Core.Name "hydra/ext/csharp/syntax.ClassBody")

data ClassMemberDeclaration = 
  ClassMemberDeclarationConstant ConstantDeclaration |
  ClassMemberDeclarationField FieldDeclaration |
  ClassMemberDeclarationMethod MethodDeclaration |
  ClassMemberDeclarationProperty PropertyDeclaration |
  ClassMemberDeclarationEvent EventDeclaration |
  ClassMemberDeclarationIndexer IndexerDeclaration |
  ClassMemberDeclarationOperator OperatorDeclaration |
  ClassMemberDeclarationConstructor ConstructorDeclaration |
  ClassMemberDeclarationFinalizer FinalizerDeclaration |
  ClassMemberDeclarationStaticConstructor StaticConstructorDeclaration |
  ClassMemberDeclarationType TypeDeclaration
  deriving (Eq, Ord, Read, Show)

_ClassMemberDeclaration = (Core.Name "hydra/ext/csharp/syntax.ClassMemberDeclaration")

_ClassMemberDeclaration_constant = (Core.Name "constant")

_ClassMemberDeclaration_field = (Core.Name "field")

_ClassMemberDeclaration_method = (Core.Name "method")

_ClassMemberDeclaration_property = (Core.Name "property")

_ClassMemberDeclaration_event = (Core.Name "event")

_ClassMemberDeclaration_indexer = (Core.Name "indexer")

_ClassMemberDeclaration_operator = (Core.Name "operator")

_ClassMemberDeclaration_constructor = (Core.Name "constructor")

_ClassMemberDeclaration_finalizer = (Core.Name "finalizer")

_ClassMemberDeclaration_staticConstructor = (Core.Name "staticConstructor")

_ClassMemberDeclaration_type = (Core.Name "type")

data ConstantDeclaration = 
  ConstantDeclaration {
    constantDeclarationAttributes :: (Maybe Attributes),
    constantDeclarationModifiers :: [ConstantModifier],
    constantDeclarationType :: Type,
    constantDeclarationDeclarators :: [ConstantDeclarator]}
  deriving (Eq, Ord, Read, Show)

_ConstantDeclaration = (Core.Name "hydra/ext/csharp/syntax.ConstantDeclaration")

_ConstantDeclaration_attributes = (Core.Name "attributes")

_ConstantDeclaration_modifiers = (Core.Name "modifiers")

_ConstantDeclaration_type = (Core.Name "type")

_ConstantDeclaration_declarators = (Core.Name "declarators")

data ConstantModifier = 
  ConstantModifierNew  |
  ConstantModifierPublic  |
  ConstantModifierProtected  |
  ConstantModifierInternal  |
  ConstantModifierPrivate 
  deriving (Eq, Ord, Read, Show)

_ConstantModifier = (Core.Name "hydra/ext/csharp/syntax.ConstantModifier")

_ConstantModifier_new = (Core.Name "new")

_ConstantModifier_public = (Core.Name "public")

_ConstantModifier_protected = (Core.Name "protected")

_ConstantModifier_internal = (Core.Name "internal")

_ConstantModifier_private = (Core.Name "private")

data FieldDeclaration = 
  FieldDeclaration {
    fieldDeclarationAttributes :: (Maybe Attributes),
    fieldDeclarationModifiers :: [FieldModifier],
    fieldDeclarationType :: Type,
    fieldDeclarationDeclarators :: [VariableDeclarator]}
  deriving (Eq, Ord, Read, Show)

_FieldDeclaration = (Core.Name "hydra/ext/csharp/syntax.FieldDeclaration")

_FieldDeclaration_attributes = (Core.Name "attributes")

_FieldDeclaration_modifiers = (Core.Name "modifiers")

_FieldDeclaration_type = (Core.Name "type")

_FieldDeclaration_declarators = (Core.Name "declarators")

data FieldModifier = 
  FieldModifierNew  |
  FieldModifierPublic  |
  FieldModifierProtected  |
  FieldModifierInternal  |
  FieldModifierPrivate  |
  FieldModifierStatic  |
  FieldModifierReadonly  |
  FieldModifierVolatile  |
  FieldModifierUnsafe 
  deriving (Eq, Ord, Read, Show)

_FieldModifier = (Core.Name "hydra/ext/csharp/syntax.FieldModifier")

_FieldModifier_new = (Core.Name "new")

_FieldModifier_public = (Core.Name "public")

_FieldModifier_protected = (Core.Name "protected")

_FieldModifier_internal = (Core.Name "internal")

_FieldModifier_private = (Core.Name "private")

_FieldModifier_static = (Core.Name "static")

_FieldModifier_readonly = (Core.Name "readonly")

_FieldModifier_volatile = (Core.Name "volatile")

_FieldModifier_unsafe = (Core.Name "unsafe")

newtype VariableDeclarators = 
  VariableDeclarators {
    unVariableDeclarators :: [VariableDeclarator]}
  deriving (Eq, Ord, Read, Show)

_VariableDeclarators = (Core.Name "hydra/ext/csharp/syntax.VariableDeclarators")

data VariableDeclarator = 
  VariableDeclarator {
    variableDeclaratorIdentifier :: Identifier,
    variableDeclaratorInitializer :: (Maybe VariableInitializer)}
  deriving (Eq, Ord, Read, Show)

_VariableDeclarator = (Core.Name "hydra/ext/csharp/syntax.VariableDeclarator")

_VariableDeclarator_identifier = (Core.Name "identifier")

_VariableDeclarator_initializer = (Core.Name "initializer")

data MethodDeclaration = 
  MethodDeclarationStandard StandardMethodDeclaration |
  MethodDeclarationRefReturn RefReturnMethodDeclaration
  deriving (Eq, Ord, Read, Show)

_MethodDeclaration = (Core.Name "hydra/ext/csharp/syntax.MethodDeclaration")

_MethodDeclaration_standard = (Core.Name "standard")

_MethodDeclaration_refReturn = (Core.Name "refReturn")

data StandardMethodDeclaration = 
  StandardMethodDeclaration {
    standardMethodDeclarationAttributes :: (Maybe Attributes),
    standardMethodDeclarationModifiers :: [MethodModifier],
    standardMethodDeclarationReturnType :: ReturnType,
    standardMethodDeclarationHeader :: MethodHeader,
    standardMethodDeclarationBody :: MethodBody}
  deriving (Eq, Ord, Read, Show)

_StandardMethodDeclaration = (Core.Name "hydra/ext/csharp/syntax.StandardMethodDeclaration")

_StandardMethodDeclaration_attributes = (Core.Name "attributes")

_StandardMethodDeclaration_modifiers = (Core.Name "modifiers")

_StandardMethodDeclaration_returnType = (Core.Name "returnType")

_StandardMethodDeclaration_header = (Core.Name "header")

_StandardMethodDeclaration_body = (Core.Name "body")

data RefReturnMethodDeclaration = 
  RefReturnMethodDeclaration {
    refReturnMethodDeclarationAttributes :: (Maybe Attributes),
    refReturnMethodDeclarationModifiers :: [RefMethodModifier],
    refReturnMethodDeclarationKind :: RefKind,
    refReturnMethodDeclarationReturnType :: ReturnType,
    refReturnMethodDeclarationHeader :: MethodHeader,
    refReturnMethodDeclarationBody :: RefMethodBody}
  deriving (Eq, Ord, Read, Show)

_RefReturnMethodDeclaration = (Core.Name "hydra/ext/csharp/syntax.RefReturnMethodDeclaration")

_RefReturnMethodDeclaration_attributes = (Core.Name "attributes")

_RefReturnMethodDeclaration_modifiers = (Core.Name "modifiers")

_RefReturnMethodDeclaration_kind = (Core.Name "kind")

_RefReturnMethodDeclaration_returnType = (Core.Name "returnType")

_RefReturnMethodDeclaration_header = (Core.Name "header")

_RefReturnMethodDeclaration_body = (Core.Name "body")

data MethodModifiers = 
  MethodModifiers {
    methodModifiersModifiers :: [MethodModifier],
    methodModifiersPartial :: Bool}
  deriving (Eq, Ord, Read, Show)

_MethodModifiers = (Core.Name "hydra/ext/csharp/syntax.MethodModifiers")

_MethodModifiers_modifiers = (Core.Name "modifiers")

_MethodModifiers_partial = (Core.Name "partial")

data RefKind = 
  RefKindRef  |
  RefKindRefReadonly 
  deriving (Eq, Ord, Read, Show)

_RefKind = (Core.Name "hydra/ext/csharp/syntax.RefKind")

_RefKind_ref = (Core.Name "ref")

_RefKind_refReadonly = (Core.Name "refReadonly")

data MethodHeader = 
  MethodHeader {
    methodHeaderName :: MemberName,
    methodHeaderTypeParameters :: (Maybe TypeParameterList),
    methodHeaderParameters :: (Maybe FormalParameterList),
    methodHeaderConstraints :: [TypeParameterConstraintsClause]}
  deriving (Eq, Ord, Read, Show)

_MethodHeader = (Core.Name "hydra/ext/csharp/syntax.MethodHeader")

_MethodHeader_name = (Core.Name "name")

_MethodHeader_typeParameters = (Core.Name "typeParameters")

_MethodHeader_parameters = (Core.Name "parameters")

_MethodHeader_constraints = (Core.Name "constraints")

data MethodModifier = 
  MethodModifierRef RefMethodModifier |
  MethodModifierAsync 
  deriving (Eq, Ord, Read, Show)

_MethodModifier = (Core.Name "hydra/ext/csharp/syntax.MethodModifier")

_MethodModifier_ref = (Core.Name "ref")

_MethodModifier_async = (Core.Name "async")

data RefMethodModifier = 
  RefMethodModifierNew  |
  RefMethodModifierPublic  |
  RefMethodModifierProtected  |
  RefMethodModifierInternal  |
  RefMethodModifierPrivate  |
  RefMethodModifierStatic  |
  RefMethodModifierVirtual  |
  RefMethodModifierSealed  |
  RefMethodModifierOverride  |
  RefMethodModifierAbstract  |
  RefMethodModifierExtern  |
  RefMethodModifierUnsafe 
  deriving (Eq, Ord, Read, Show)

_RefMethodModifier = (Core.Name "hydra/ext/csharp/syntax.RefMethodModifier")

_RefMethodModifier_new = (Core.Name "new")

_RefMethodModifier_public = (Core.Name "public")

_RefMethodModifier_protected = (Core.Name "protected")

_RefMethodModifier_internal = (Core.Name "internal")

_RefMethodModifier_private = (Core.Name "private")

_RefMethodModifier_static = (Core.Name "static")

_RefMethodModifier_virtual = (Core.Name "virtual")

_RefMethodModifier_sealed = (Core.Name "sealed")

_RefMethodModifier_override = (Core.Name "override")

_RefMethodModifier_abstract = (Core.Name "abstract")

_RefMethodModifier_extern = (Core.Name "extern")

_RefMethodModifier_unsafe = (Core.Name "unsafe")

data ReturnType = 
  ReturnTypeRef Type |
  ReturnTypeVoid 
  deriving (Eq, Ord, Read, Show)

_ReturnType = (Core.Name "hydra/ext/csharp/syntax.ReturnType")

_ReturnType_ref = (Core.Name "ref")

_ReturnType_void = (Core.Name "void")

data MemberName = 
  MemberName {
    memberNameInterfaceType :: (Maybe TypeName),
    memberNameIdentifier :: Identifier}
  deriving (Eq, Ord, Read, Show)

_MemberName = (Core.Name "hydra/ext/csharp/syntax.MemberName")

_MemberName_interfaceType = (Core.Name "interfaceType")

_MemberName_identifier = (Core.Name "identifier")

data MethodBody = 
  MethodBodyBlock Block |
  MethodBodyNullConditionalInvocation NullConditionalInvocationExpression |
  MethodBodyExpression Expression |
  MethodBodyEmpty 
  deriving (Eq, Ord, Read, Show)

_MethodBody = (Core.Name "hydra/ext/csharp/syntax.MethodBody")

_MethodBody_block = (Core.Name "block")

_MethodBody_nullConditionalInvocation = (Core.Name "nullConditionalInvocation")

_MethodBody_expression = (Core.Name "expression")

_MethodBody_empty = (Core.Name "empty")

data RefMethodBody = 
  RefMethodBodyBlock Block |
  RefMethodBodyRef VariableReference |
  RefMethodBodyEmpty 
  deriving (Eq, Ord, Read, Show)

_RefMethodBody = (Core.Name "hydra/ext/csharp/syntax.RefMethodBody")

_RefMethodBody_block = (Core.Name "block")

_RefMethodBody_ref = (Core.Name "ref")

_RefMethodBody_empty = (Core.Name "empty")

data FormalParameterList = 
  FormalParameterList {
    formalParameterListFixed :: [FixedParameter],
    formalParameterListArray :: (Maybe ParameterArray)}
  deriving (Eq, Ord, Read, Show)

_FormalParameterList = (Core.Name "hydra/ext/csharp/syntax.FormalParameterList")

_FormalParameterList_fixed = (Core.Name "fixed")

_FormalParameterList_array = (Core.Name "array")

data FixedParameter = 
  FixedParameter {
    fixedParameterAttributes :: (Maybe Attributes),
    fixedParameterModifier :: (Maybe ParameterModifier),
    fixedParameterType :: Type,
    fixedParameterIdentifier :: Identifier,
    fixedParameterDefaultArgument :: (Maybe Expression)}
  deriving (Eq, Ord, Read, Show)

_FixedParameter = (Core.Name "hydra/ext/csharp/syntax.FixedParameter")

_FixedParameter_attributes = (Core.Name "attributes")

_FixedParameter_modifier = (Core.Name "modifier")

_FixedParameter_type = (Core.Name "type")

_FixedParameter_identifier = (Core.Name "identifier")

_FixedParameter_defaultArgument = (Core.Name "defaultArgument")

data ParameterModifier = 
  ParameterModifierMode ParameterModeModifier |
  ParameterModifierThis 
  deriving (Eq, Ord, Read, Show)

_ParameterModifier = (Core.Name "hydra/ext/csharp/syntax.ParameterModifier")

_ParameterModifier_mode = (Core.Name "mode")

_ParameterModifier_this = (Core.Name "this")

data ParameterModeModifier = 
  ParameterModeModifierRef  |
  ParameterModeModifierOut  |
  ParameterModeModifierIn 
  deriving (Eq, Ord, Read, Show)

_ParameterModeModifier = (Core.Name "hydra/ext/csharp/syntax.ParameterModeModifier")

_ParameterModeModifier_ref = (Core.Name "ref")

_ParameterModeModifier_out = (Core.Name "out")

_ParameterModeModifier_in = (Core.Name "in")

data ParameterArray = 
  ParameterArray {
    parameterArrayAttributes :: (Maybe Attributes),
    parameterArrayType :: ArrayType,
    parameterArrayIdentifier :: Identifier}
  deriving (Eq, Ord, Read, Show)

_ParameterArray = (Core.Name "hydra/ext/csharp/syntax.ParameterArray")

_ParameterArray_attributes = (Core.Name "attributes")

_ParameterArray_type = (Core.Name "type")

_ParameterArray_identifier = (Core.Name "identifier")

data PropertyDeclaration = 
  PropertyDeclarationStandard StandardPropertyDeclaration |
  PropertyDeclarationRefReturn RefReturnPropertyDeclaration
  deriving (Eq, Ord, Read, Show)

_PropertyDeclaration = (Core.Name "hydra/ext/csharp/syntax.PropertyDeclaration")

_PropertyDeclaration_standard = (Core.Name "standard")

_PropertyDeclaration_refReturn = (Core.Name "refReturn")

data StandardPropertyDeclaration = 
  StandardPropertyDeclaration {
    standardPropertyDeclarationAttributes :: (Maybe Attributes),
    standardPropertyDeclarationModifiers :: [PropertyModifier],
    standardPropertyDeclarationType :: Type,
    standardPropertyDeclarationName :: MemberName,
    standardPropertyDeclarationBody :: PropertyBody}
  deriving (Eq, Ord, Read, Show)

_StandardPropertyDeclaration = (Core.Name "hydra/ext/csharp/syntax.StandardPropertyDeclaration")

_StandardPropertyDeclaration_attributes = (Core.Name "attributes")

_StandardPropertyDeclaration_modifiers = (Core.Name "modifiers")

_StandardPropertyDeclaration_type = (Core.Name "type")

_StandardPropertyDeclaration_name = (Core.Name "name")

_StandardPropertyDeclaration_body = (Core.Name "body")

data RefReturnPropertyDeclaration = 
  RefReturnPropertyDeclaration {
    refReturnPropertyDeclarationAttributes :: (Maybe Attributes),
    refReturnPropertyDeclarationModifiers :: [PropertyModifier],
    refReturnPropertyDeclarationRefKind :: RefKind,
    refReturnPropertyDeclarationType :: Type,
    refReturnPropertyDeclarationName :: MemberName,
    refReturnPropertyDeclarationBody :: RefPropertyBody}
  deriving (Eq, Ord, Read, Show)

_RefReturnPropertyDeclaration = (Core.Name "hydra/ext/csharp/syntax.RefReturnPropertyDeclaration")

_RefReturnPropertyDeclaration_attributes = (Core.Name "attributes")

_RefReturnPropertyDeclaration_modifiers = (Core.Name "modifiers")

_RefReturnPropertyDeclaration_refKind = (Core.Name "refKind")

_RefReturnPropertyDeclaration_type = (Core.Name "type")

_RefReturnPropertyDeclaration_name = (Core.Name "name")

_RefReturnPropertyDeclaration_body = (Core.Name "body")

data PropertyModifier = 
  PropertyModifierNew  |
  PropertyModifierPublic  |
  PropertyModifierProtected  |
  PropertyModifierInternal  |
  PropertyModifierPrivate  |
  PropertyModifierStatic  |
  PropertyModifierVirtual  |
  PropertyModifierSealed  |
  PropertyModifierOverride  |
  PropertyModifierAbstract  |
  PropertyModifierExtern  |
  PropertyModifierUnsafe 
  deriving (Eq, Ord, Read, Show)

_PropertyModifier = (Core.Name "hydra/ext/csharp/syntax.PropertyModifier")

_PropertyModifier_new = (Core.Name "new")

_PropertyModifier_public = (Core.Name "public")

_PropertyModifier_protected = (Core.Name "protected")

_PropertyModifier_internal = (Core.Name "internal")

_PropertyModifier_private = (Core.Name "private")

_PropertyModifier_static = (Core.Name "static")

_PropertyModifier_virtual = (Core.Name "virtual")

_PropertyModifier_sealed = (Core.Name "sealed")

_PropertyModifier_override = (Core.Name "override")

_PropertyModifier_abstract = (Core.Name "abstract")

_PropertyModifier_extern = (Core.Name "extern")

_PropertyModifier_unsafe = (Core.Name "unsafe")

data PropertyBody = 
  PropertyBodyBlock BlockPropertyBody |
  PropertyBodyExpression Expression
  deriving (Eq, Ord, Read, Show)

_PropertyBody = (Core.Name "hydra/ext/csharp/syntax.PropertyBody")

_PropertyBody_block = (Core.Name "block")

_PropertyBody_expression = (Core.Name "expression")

data BlockPropertyBody = 
  BlockPropertyBody {
    blockPropertyBodyAccessors :: AccessorDeclarations,
    blockPropertyBodyInitializer :: (Maybe VariableInitializer)}
  deriving (Eq, Ord, Read, Show)

_BlockPropertyBody = (Core.Name "hydra/ext/csharp/syntax.BlockPropertyBody")

_BlockPropertyBody_accessors = (Core.Name "accessors")

_BlockPropertyBody_initializer = (Core.Name "initializer")

data RefPropertyBody = 
  RefPropertyBodyBlock RefGetAccessorDeclaration |
  RefPropertyBodyRef VariableReference
  deriving (Eq, Ord, Read, Show)

_RefPropertyBody = (Core.Name "hydra/ext/csharp/syntax.RefPropertyBody")

_RefPropertyBody_block = (Core.Name "block")

_RefPropertyBody_ref = (Core.Name "ref")

data AccessorDeclarations = 
  AccessorDeclarationsGet (Maybe AccessorDeclaration) |
  AccessorDeclarationsSet (Maybe AccessorDeclaration)
  deriving (Eq, Ord, Read, Show)

_AccessorDeclarations = (Core.Name "hydra/ext/csharp/syntax.AccessorDeclarations")

_AccessorDeclarations_get = (Core.Name "get")

_AccessorDeclarations_set = (Core.Name "set")

data AccessorDeclaration = 
  AccessorDeclaration {
    accessorDeclarationAttributes :: (Maybe Attributes),
    accessorDeclarationModifier :: (Maybe AccessorModifier),
    accessorDeclarationBody :: AccessorBody}
  deriving (Eq, Ord, Read, Show)

_AccessorDeclaration = (Core.Name "hydra/ext/csharp/syntax.AccessorDeclaration")

_AccessorDeclaration_attributes = (Core.Name "attributes")

_AccessorDeclaration_modifier = (Core.Name "modifier")

_AccessorDeclaration_body = (Core.Name "body")

data AccessorModifier = 
  AccessorModifierProtected  |
  AccessorModifierInternal  |
  AccessorModifierPrivate  |
  AccessorModifierProtectedInternal  |
  AccessorModifierInternalProtected  |
  AccessorModifierProtectedPrivate  |
  AccessorModifierPrivateProtected 
  deriving (Eq, Ord, Read, Show)

_AccessorModifier = (Core.Name "hydra/ext/csharp/syntax.AccessorModifier")

_AccessorModifier_protected = (Core.Name "protected")

_AccessorModifier_internal = (Core.Name "internal")

_AccessorModifier_private = (Core.Name "private")

_AccessorModifier_protectedInternal = (Core.Name "protectedInternal")

_AccessorModifier_internalProtected = (Core.Name "internalProtected")

_AccessorModifier_protectedPrivate = (Core.Name "protectedPrivate")

_AccessorModifier_privateProtected = (Core.Name "privateProtected")

data AccessorBody = 
  AccessorBodyBlock Block |
  AccessorBodyExpression Expression |
  AccessorBodyEmpty 
  deriving (Eq, Ord, Read, Show)

_AccessorBody = (Core.Name "hydra/ext/csharp/syntax.AccessorBody")

_AccessorBody_block = (Core.Name "block")

_AccessorBody_expression = (Core.Name "expression")

_AccessorBody_empty = (Core.Name "empty")

data RefGetAccessorDeclaration = 
  RefGetAccessorDeclaration {
    refGetAccessorDeclarationAttributes :: (Maybe Attributes),
    refGetAccessorDeclarationModifier :: (Maybe AccessorModifier),
    refGetAccessorDeclarationBody :: RefAccessorBody}
  deriving (Eq, Ord, Read, Show)

_RefGetAccessorDeclaration = (Core.Name "hydra/ext/csharp/syntax.RefGetAccessorDeclaration")

_RefGetAccessorDeclaration_attributes = (Core.Name "attributes")

_RefGetAccessorDeclaration_modifier = (Core.Name "modifier")

_RefGetAccessorDeclaration_body = (Core.Name "body")

data RefAccessorBody = 
  RefAccessorBodyBlock Block |
  RefAccessorBodyRef VariableReference |
  RefAccessorBodyEmpty 
  deriving (Eq, Ord, Read, Show)

_RefAccessorBody = (Core.Name "hydra/ext/csharp/syntax.RefAccessorBody")

_RefAccessorBody_block = (Core.Name "block")

_RefAccessorBody_ref = (Core.Name "ref")

_RefAccessorBody_empty = (Core.Name "empty")

data EventDeclaration = 
  EventDeclarationStandard StandardEventDeclaration |
  EventDeclarationAccessors AccessorsEventDeclaration
  deriving (Eq, Ord, Read, Show)

_EventDeclaration = (Core.Name "hydra/ext/csharp/syntax.EventDeclaration")

_EventDeclaration_standard = (Core.Name "standard")

_EventDeclaration_accessors = (Core.Name "accessors")

data StandardEventDeclaration = 
  StandardEventDeclaration {
    standardEventDeclarationAttributes :: (Maybe Attributes),
    standardEventDeclarationModifiers :: [EventModifier],
    standardEventDeclarationType :: Type,
    standardEventDeclarationDeclarators :: VariableDeclarators}
  deriving (Eq, Ord, Read, Show)

_StandardEventDeclaration = (Core.Name "hydra/ext/csharp/syntax.StandardEventDeclaration")

_StandardEventDeclaration_attributes = (Core.Name "attributes")

_StandardEventDeclaration_modifiers = (Core.Name "modifiers")

_StandardEventDeclaration_type = (Core.Name "type")

_StandardEventDeclaration_declarators = (Core.Name "declarators")

data AccessorsEventDeclaration = 
  AccessorsEventDeclaration {
    accessorsEventDeclarationAttributes :: (Maybe Attributes),
    accessorsEventDeclarationModifiers :: [EventModifier],
    accessorsEventDeclarationType :: Type,
    accessorsEventDeclarationName :: MemberName,
    accessorsEventDeclarationAccessors :: EventAccessorDeclarations}
  deriving (Eq, Ord, Read, Show)

_AccessorsEventDeclaration = (Core.Name "hydra/ext/csharp/syntax.AccessorsEventDeclaration")

_AccessorsEventDeclaration_attributes = (Core.Name "attributes")

_AccessorsEventDeclaration_modifiers = (Core.Name "modifiers")

_AccessorsEventDeclaration_type = (Core.Name "type")

_AccessorsEventDeclaration_name = (Core.Name "name")

_AccessorsEventDeclaration_accessors = (Core.Name "accessors")

data EventModifier = 
  EventModifierNew  |
  EventModifierPublic  |
  EventModifierProtected  |
  EventModifierInternal  |
  EventModifierPrivate  |
  EventModifierStatic  |
  EventModifierVirtual  |
  EventModifierSealed  |
  EventModifierOverride  |
  EventModifierAbstract  |
  EventModifierExtern  |
  EventModifierUnsafe 
  deriving (Eq, Ord, Read, Show)

_EventModifier = (Core.Name "hydra/ext/csharp/syntax.EventModifier")

_EventModifier_new = (Core.Name "new")

_EventModifier_public = (Core.Name "public")

_EventModifier_protected = (Core.Name "protected")

_EventModifier_internal = (Core.Name "internal")

_EventModifier_private = (Core.Name "private")

_EventModifier_static = (Core.Name "static")

_EventModifier_virtual = (Core.Name "virtual")

_EventModifier_sealed = (Core.Name "sealed")

_EventModifier_override = (Core.Name "override")

_EventModifier_abstract = (Core.Name "abstract")

_EventModifier_extern = (Core.Name "extern")

_EventModifier_unsafe = (Core.Name "unsafe")

data EventAccessorDeclarations = 
  EventAccessorDeclarationsAdd AddRemoveAccessorDeclaration |
  EventAccessorDeclarationsRemove AddRemoveAccessorDeclaration
  deriving (Eq, Ord, Read, Show)

_EventAccessorDeclarations = (Core.Name "hydra/ext/csharp/syntax.EventAccessorDeclarations")

_EventAccessorDeclarations_add = (Core.Name "add")

_EventAccessorDeclarations_remove = (Core.Name "remove")

data AddRemoveAccessorDeclaration = 
  AddRemoveAccessorDeclaration {
    addRemoveAccessorDeclarationAttributes :: (Maybe Attributes),
    addRemoveAccessorDeclarationBody :: Block}
  deriving (Eq, Ord, Read, Show)

_AddRemoveAccessorDeclaration = (Core.Name "hydra/ext/csharp/syntax.AddRemoveAccessorDeclaration")

_AddRemoveAccessorDeclaration_attributes = (Core.Name "attributes")

_AddRemoveAccessorDeclaration_body = (Core.Name "body")

data IndexerDeclaration = 
  IndexerDeclarationStandard StandardIndexerDeclaration |
  IndexerDeclarationRef RefIndexerDeclaration
  deriving (Eq, Ord, Read, Show)

_IndexerDeclaration = (Core.Name "hydra/ext/csharp/syntax.IndexerDeclaration")

_IndexerDeclaration_standard = (Core.Name "standard")

_IndexerDeclaration_ref = (Core.Name "ref")

data StandardIndexerDeclaration = 
  StandardIndexerDeclaration {
    standardIndexerDeclarationAttributes :: (Maybe Attributes),
    standardIndexerDeclarationModifiers :: [IndexerModifier],
    standardIndexerDeclarationDeclarator :: IndexerDeclarator,
    standardIndexerDeclarationBody :: IndexerBody}
  deriving (Eq, Ord, Read, Show)

_StandardIndexerDeclaration = (Core.Name "hydra/ext/csharp/syntax.StandardIndexerDeclaration")

_StandardIndexerDeclaration_attributes = (Core.Name "attributes")

_StandardIndexerDeclaration_modifiers = (Core.Name "modifiers")

_StandardIndexerDeclaration_declarator = (Core.Name "declarator")

_StandardIndexerDeclaration_body = (Core.Name "body")

data RefIndexerDeclaration = 
  RefIndexerDeclaration {
    refIndexerDeclarationAttributes :: (Maybe Attributes),
    refIndexerDeclarationModifiers :: [IndexerModifier],
    refIndexerDeclarationRefKind :: RefKind,
    refIndexerDeclarationDeclarator :: IndexerDeclarator,
    refIndexerDeclarationBody :: RefIndexerBody}
  deriving (Eq, Ord, Read, Show)

_RefIndexerDeclaration = (Core.Name "hydra/ext/csharp/syntax.RefIndexerDeclaration")

_RefIndexerDeclaration_attributes = (Core.Name "attributes")

_RefIndexerDeclaration_modifiers = (Core.Name "modifiers")

_RefIndexerDeclaration_refKind = (Core.Name "refKind")

_RefIndexerDeclaration_declarator = (Core.Name "declarator")

_RefIndexerDeclaration_body = (Core.Name "body")

data IndexerModifier = 
  IndexerModifierNew  |
  IndexerModifierPublic  |
  IndexerModifierProtected  |
  IndexerModifierInternal  |
  IndexerModifierPrivate  |
  IndexerModifierVirtual  |
  IndexerModifierSealed  |
  IndexerModifierOverride  |
  IndexerModifierAbstract  |
  IndexerModifierExtern  |
  IndexerModifierUnsafe 
  deriving (Eq, Ord, Read, Show)

_IndexerModifier = (Core.Name "hydra/ext/csharp/syntax.IndexerModifier")

_IndexerModifier_new = (Core.Name "new")

_IndexerModifier_public = (Core.Name "public")

_IndexerModifier_protected = (Core.Name "protected")

_IndexerModifier_internal = (Core.Name "internal")

_IndexerModifier_private = (Core.Name "private")

_IndexerModifier_virtual = (Core.Name "virtual")

_IndexerModifier_sealed = (Core.Name "sealed")

_IndexerModifier_override = (Core.Name "override")

_IndexerModifier_abstract = (Core.Name "abstract")

_IndexerModifier_extern = (Core.Name "extern")

_IndexerModifier_unsafe = (Core.Name "unsafe")

data IndexerDeclarator = 
  IndexerDeclarator {
    indexerDeclaratorType :: Type,
    indexerDeclaratorInterface :: (Maybe InterfaceType),
    indexerDeclaratorParameters :: FormalParameterList}
  deriving (Eq, Ord, Read, Show)

_IndexerDeclarator = (Core.Name "hydra/ext/csharp/syntax.IndexerDeclarator")

_IndexerDeclarator_type = (Core.Name "type")

_IndexerDeclarator_interface = (Core.Name "interface")

_IndexerDeclarator_parameters = (Core.Name "parameters")

data IndexerBody = 
  IndexerBodyBlock AccessorDeclarations |
  IndexerBodyExpression Expression
  deriving (Eq, Ord, Read, Show)

_IndexerBody = (Core.Name "hydra/ext/csharp/syntax.IndexerBody")

_IndexerBody_block = (Core.Name "block")

_IndexerBody_expression = (Core.Name "expression")

data RefIndexerBody = 
  RefIndexerBodyBlock RefGetAccessorDeclaration |
  RefIndexerBodyRef VariableReference
  deriving (Eq, Ord, Read, Show)

_RefIndexerBody = (Core.Name "hydra/ext/csharp/syntax.RefIndexerBody")

_RefIndexerBody_block = (Core.Name "block")

_RefIndexerBody_ref = (Core.Name "ref")

data OperatorDeclaration = 
  OperatorDeclaration {
    operatorDeclarationAttributes :: (Maybe Attributes),
    operatorDeclarationModifiers :: [OperatorModifier],
    operatorDeclarationDeclarator :: OperatorDeclarator,
    operatorDeclarationBody :: OperatorBody}
  deriving (Eq, Ord, Read, Show)

_OperatorDeclaration = (Core.Name "hydra/ext/csharp/syntax.OperatorDeclaration")

_OperatorDeclaration_attributes = (Core.Name "attributes")

_OperatorDeclaration_modifiers = (Core.Name "modifiers")

_OperatorDeclaration_declarator = (Core.Name "declarator")

_OperatorDeclaration_body = (Core.Name "body")

data OperatorModifier = 
  OperatorModifierPublic  |
  OperatorModifierStatic  |
  OperatorModifierExtern  |
  OperatorModifierUnsafe 
  deriving (Eq, Ord, Read, Show)

_OperatorModifier = (Core.Name "hydra/ext/csharp/syntax.OperatorModifier")

_OperatorModifier_public = (Core.Name "public")

_OperatorModifier_static = (Core.Name "static")

_OperatorModifier_extern = (Core.Name "extern")

_OperatorModifier_unsafe = (Core.Name "unsafe")

data OperatorDeclarator = 
  OperatorDeclaratorUnary UnaryOperatorDeclarator |
  OperatorDeclaratorBinary BinaryOperatorDeclarator |
  OperatorDeclaratorConversion ConversionOperatorDeclarator
  deriving (Eq, Ord, Read, Show)

_OperatorDeclarator = (Core.Name "hydra/ext/csharp/syntax.OperatorDeclarator")

_OperatorDeclarator_unary = (Core.Name "unary")

_OperatorDeclarator_binary = (Core.Name "binary")

_OperatorDeclarator_conversion = (Core.Name "conversion")

data UnaryOperatorDeclarator = 
  UnaryOperatorDeclarator {
    unaryOperatorDeclaratorType :: Type,
    unaryOperatorDeclaratorOperator :: OverloadableUnaryOperator,
    unaryOperatorDeclaratorParameter :: FixedParameter}
  deriving (Eq, Ord, Read, Show)

_UnaryOperatorDeclarator = (Core.Name "hydra/ext/csharp/syntax.UnaryOperatorDeclarator")

_UnaryOperatorDeclarator_type = (Core.Name "type")

_UnaryOperatorDeclarator_operator = (Core.Name "operator")

_UnaryOperatorDeclarator_parameter = (Core.Name "parameter")

data OverloadableUnaryOperator = 
  OverloadableUnaryOperatorPlus  |
  OverloadableUnaryOperatorMinus  |
  OverloadableUnaryOperatorNot  |
  OverloadableUnaryOperatorComplement  |
  OverloadableUnaryOperatorIncrement  |
  OverloadableUnaryOperatorDecrement  |
  OverloadableUnaryOperatorTrue  |
  OverloadableUnaryOperatorFalse 
  deriving (Eq, Ord, Read, Show)

_OverloadableUnaryOperator = (Core.Name "hydra/ext/csharp/syntax.OverloadableUnaryOperator")

_OverloadableUnaryOperator_plus = (Core.Name "plus")

_OverloadableUnaryOperator_minus = (Core.Name "minus")

_OverloadableUnaryOperator_not = (Core.Name "not")

_OverloadableUnaryOperator_complement = (Core.Name "complement")

_OverloadableUnaryOperator_increment = (Core.Name "increment")

_OverloadableUnaryOperator_decrement = (Core.Name "decrement")

_OverloadableUnaryOperator_true = (Core.Name "true")

_OverloadableUnaryOperator_false = (Core.Name "false")

data BinaryOperatorDeclarator = 
  BinaryOperatorDeclarator {
    binaryOperatorDeclaratorType :: Type,
    binaryOperatorDeclaratorOperator :: OverloadableBinaryOperator,
    binaryOperatorDeclaratorLeft :: FixedParameter,
    binaryOperatorDeclaratorRight :: FixedParameter}
  deriving (Eq, Ord, Read, Show)

_BinaryOperatorDeclarator = (Core.Name "hydra/ext/csharp/syntax.BinaryOperatorDeclarator")

_BinaryOperatorDeclarator_type = (Core.Name "type")

_BinaryOperatorDeclarator_operator = (Core.Name "operator")

_BinaryOperatorDeclarator_left = (Core.Name "left")

_BinaryOperatorDeclarator_right = (Core.Name "right")

data OverloadableBinaryOperator = 
  OverloadableBinaryOperatorAdd  |
  OverloadableBinaryOperatorSubtract  |
  OverloadableBinaryOperatorMultiply  |
  OverloadableBinaryOperatorDivide  |
  OverloadableBinaryOperatorModulus  |
  OverloadableBinaryOperatorAnd  |
  OverloadableBinaryOperatorOr  |
  OverloadableBinaryOperatorXor  |
  OverloadableBinaryOperatorLeftShift  |
  OverloadableBinaryOperatorRightShift  |
  OverloadableBinaryOperatorEqual  |
  OverloadableBinaryOperatorNotEqual  |
  OverloadableBinaryOperatorGreaterThan  |
  OverloadableBinaryOperatorLessThan  |
  OverloadableBinaryOperatorGreaterThanOrEqual  |
  OverloadableBinaryOperatorLessThanOrEqual 
  deriving (Eq, Ord, Read, Show)

_OverloadableBinaryOperator = (Core.Name "hydra/ext/csharp/syntax.OverloadableBinaryOperator")

_OverloadableBinaryOperator_add = (Core.Name "add")

_OverloadableBinaryOperator_subtract = (Core.Name "subtract")

_OverloadableBinaryOperator_multiply = (Core.Name "multiply")

_OverloadableBinaryOperator_divide = (Core.Name "divide")

_OverloadableBinaryOperator_modulus = (Core.Name "modulus")

_OverloadableBinaryOperator_and = (Core.Name "and")

_OverloadableBinaryOperator_or = (Core.Name "or")

_OverloadableBinaryOperator_xor = (Core.Name "xor")

_OverloadableBinaryOperator_leftShift = (Core.Name "leftShift")

_OverloadableBinaryOperator_rightShift = (Core.Name "rightShift")

_OverloadableBinaryOperator_equal = (Core.Name "equal")

_OverloadableBinaryOperator_notEqual = (Core.Name "notEqual")

_OverloadableBinaryOperator_greaterThan = (Core.Name "greaterThan")

_OverloadableBinaryOperator_lessThan = (Core.Name "lessThan")

_OverloadableBinaryOperator_greaterThanOrEqual = (Core.Name "greaterThanOrEqual")

_OverloadableBinaryOperator_lessThanOrEqual = (Core.Name "lessThanOrEqual")

data ConversionOperatorDeclarator = 
  ConversionOperatorDeclarator {
    conversionOperatorDeclaratorKind :: ConversionKind,
    conversionOperatorDeclaratorType :: Type,
    conversionOperatorDeclaratorParameter :: FixedParameter}
  deriving (Eq, Ord, Read, Show)

_ConversionOperatorDeclarator = (Core.Name "hydra/ext/csharp/syntax.ConversionOperatorDeclarator")

_ConversionOperatorDeclarator_kind = (Core.Name "kind")

_ConversionOperatorDeclarator_type = (Core.Name "type")

_ConversionOperatorDeclarator_parameter = (Core.Name "parameter")

data ConversionKind = 
  ConversionKindImplicit  |
  ConversionKindExplicit 
  deriving (Eq, Ord, Read, Show)

_ConversionKind = (Core.Name "hydra/ext/csharp/syntax.ConversionKind")

_ConversionKind_implicit = (Core.Name "implicit")

_ConversionKind_explicit = (Core.Name "explicit")

data OperatorBody = 
  OperatorBodyBlock Block |
  OperatorBodyExpression Expression |
  OperatorBodyEmpty 
  deriving (Eq, Ord, Read, Show)

_OperatorBody = (Core.Name "hydra/ext/csharp/syntax.OperatorBody")

_OperatorBody_block = (Core.Name "block")

_OperatorBody_expression = (Core.Name "expression")

_OperatorBody_empty = (Core.Name "empty")

data ConstructorDeclaration = 
  ConstructorDeclaration {
    constructorDeclarationAttributes :: (Maybe Attributes),
    constructorDeclarationModifiers :: [ConstructorModifier],
    constructorDeclarationDeclarator :: ConstructorDeclarator,
    constructorDeclarationBody :: ConstructorBody}
  deriving (Eq, Ord, Read, Show)

_ConstructorDeclaration = (Core.Name "hydra/ext/csharp/syntax.ConstructorDeclaration")

_ConstructorDeclaration_attributes = (Core.Name "attributes")

_ConstructorDeclaration_modifiers = (Core.Name "modifiers")

_ConstructorDeclaration_declarator = (Core.Name "declarator")

_ConstructorDeclaration_body = (Core.Name "body")

data ConstructorModifier = 
  ConstructorModifierPublic  |
  ConstructorModifierProtected  |
  ConstructorModifierInternal  |
  ConstructorModifierPrivate  |
  ConstructorModifierExtern  |
  ConstructorModifierUnsafe 
  deriving (Eq, Ord, Read, Show)

_ConstructorModifier = (Core.Name "hydra/ext/csharp/syntax.ConstructorModifier")

_ConstructorModifier_public = (Core.Name "public")

_ConstructorModifier_protected = (Core.Name "protected")

_ConstructorModifier_internal = (Core.Name "internal")

_ConstructorModifier_private = (Core.Name "private")

_ConstructorModifier_extern = (Core.Name "extern")

_ConstructorModifier_unsafe = (Core.Name "unsafe")

data ConstructorDeclarator = 
  ConstructorDeclarator {
    constructorDeclaratorName :: Identifier,
    constructorDeclaratorParameters :: (Maybe FormalParameterList),
    constructorDeclaratorInitializer :: (Maybe ConstructorInitializer)}
  deriving (Eq, Ord, Read, Show)

_ConstructorDeclarator = (Core.Name "hydra/ext/csharp/syntax.ConstructorDeclarator")

_ConstructorDeclarator_name = (Core.Name "name")

_ConstructorDeclarator_parameters = (Core.Name "parameters")

_ConstructorDeclarator_initializer = (Core.Name "initializer")

data ConstructorInitializer = 
  ConstructorInitializerBase (Maybe ArgumentList) |
  ConstructorInitializerThis (Maybe ArgumentList)
  deriving (Eq, Ord, Read, Show)

_ConstructorInitializer = (Core.Name "hydra/ext/csharp/syntax.ConstructorInitializer")

_ConstructorInitializer_base = (Core.Name "base")

_ConstructorInitializer_this = (Core.Name "this")

data ConstructorBody = 
  ConstructorBodyBlock Block |
  ConstructorBodyExpression Expression |
  ConstructorBodyEmpty 
  deriving (Eq, Ord, Read, Show)

_ConstructorBody = (Core.Name "hydra/ext/csharp/syntax.ConstructorBody")

_ConstructorBody_block = (Core.Name "block")

_ConstructorBody_expression = (Core.Name "expression")

_ConstructorBody_empty = (Core.Name "empty")

data StaticConstructorDeclaration = 
  StaticConstructorDeclaration {
    staticConstructorDeclarationAttributes :: (Maybe Attributes),
    staticConstructorDeclarationModifiers :: StaticConstructorModifiers,
    staticConstructorDeclarationName :: Identifier,
    staticConstructorDeclarationBody :: StaticConstructorBody}
  deriving (Eq, Ord, Read, Show)

_StaticConstructorDeclaration = (Core.Name "hydra/ext/csharp/syntax.StaticConstructorDeclaration")

_StaticConstructorDeclaration_attributes = (Core.Name "attributes")

_StaticConstructorDeclaration_modifiers = (Core.Name "modifiers")

_StaticConstructorDeclaration_name = (Core.Name "name")

_StaticConstructorDeclaration_body = (Core.Name "body")

data StaticConstructorModifiers = 
  StaticConstructorModifiers {
    staticConstructorModifiersExtern :: Bool,
    staticConstructorModifiersUnsafe :: Bool}
  deriving (Eq, Ord, Read, Show)

_StaticConstructorModifiers = (Core.Name "hydra/ext/csharp/syntax.StaticConstructorModifiers")

_StaticConstructorModifiers_extern = (Core.Name "extern")

_StaticConstructorModifiers_unsafe = (Core.Name "unsafe")

data StaticConstructorBody = 
  StaticConstructorBodyBlock Block |
  StaticConstructorBodyExpression Expression |
  StaticConstructorBodyEmpty 
  deriving (Eq, Ord, Read, Show)

_StaticConstructorBody = (Core.Name "hydra/ext/csharp/syntax.StaticConstructorBody")

_StaticConstructorBody_block = (Core.Name "block")

_StaticConstructorBody_expression = (Core.Name "expression")

_StaticConstructorBody_empty = (Core.Name "empty")

data FinalizerDeclaration = 
  FinalizerDeclaration {
    finalizerDeclarationAttributes :: (Maybe Attributes),
    finalizerDeclarationExtern :: Bool,
    finalizerDeclarationUnsafe :: Bool,
    finalizerDeclarationName :: Identifier,
    finalizerDeclarationBody :: FinalizerBody}
  deriving (Eq, Ord, Read, Show)

_FinalizerDeclaration = (Core.Name "hydra/ext/csharp/syntax.FinalizerDeclaration")

_FinalizerDeclaration_attributes = (Core.Name "attributes")

_FinalizerDeclaration_extern = (Core.Name "extern")

_FinalizerDeclaration_unsafe = (Core.Name "unsafe")

_FinalizerDeclaration_name = (Core.Name "name")

_FinalizerDeclaration_body = (Core.Name "body")

data FinalizerBody = 
  FinalizerBodyBlock Block |
  FinalizerBodyExpression Expression |
  FinalizerBodyEmpty 
  deriving (Eq, Ord, Read, Show)

_FinalizerBody = (Core.Name "hydra/ext/csharp/syntax.FinalizerBody")

_FinalizerBody_block = (Core.Name "block")

_FinalizerBody_expression = (Core.Name "expression")

_FinalizerBody_empty = (Core.Name "empty")

data StructDeclaration = 
  StructDeclaration {
    structDeclarationAttributes :: (Maybe Attributes),
    structDeclarationModifiers :: [StructModifier],
    structDeclarationRef :: Bool,
    structDeclarationPartial :: Bool,
    structDeclarationName :: Identifier,
    structDeclarationParameters :: (Maybe TypeParameterList),
    structDeclarationInterfaces :: [InterfaceType],
    structDeclarationConstraints :: [TypeParameterConstraintsClause],
    structDeclarationBody :: [StructMemberDeclaration]}
  deriving (Eq, Ord, Read, Show)

_StructDeclaration = (Core.Name "hydra/ext/csharp/syntax.StructDeclaration")

_StructDeclaration_attributes = (Core.Name "attributes")

_StructDeclaration_modifiers = (Core.Name "modifiers")

_StructDeclaration_ref = (Core.Name "ref")

_StructDeclaration_partial = (Core.Name "partial")

_StructDeclaration_name = (Core.Name "name")

_StructDeclaration_parameters = (Core.Name "parameters")

_StructDeclaration_interfaces = (Core.Name "interfaces")

_StructDeclaration_constraints = (Core.Name "constraints")

_StructDeclaration_body = (Core.Name "body")

data StructModifier = 
  StructModifierNew  |
  StructModifierPublic  |
  StructModifierProtected  |
  StructModifierInternal  |
  StructModifierPrivate  |
  StructModifierReadonly  |
  StructModifierUnsafe 
  deriving (Eq, Ord, Read, Show)

_StructModifier = (Core.Name "hydra/ext/csharp/syntax.StructModifier")

_StructModifier_new = (Core.Name "new")

_StructModifier_public = (Core.Name "public")

_StructModifier_protected = (Core.Name "protected")

_StructModifier_internal = (Core.Name "internal")

_StructModifier_private = (Core.Name "private")

_StructModifier_readonly = (Core.Name "readonly")

_StructModifier_unsafe = (Core.Name "unsafe")

data StructMemberDeclaration = 
  StructMemberDeclarationConstant ConstantDeclaration |
  StructMemberDeclarationField FieldDeclaration |
  StructMemberDeclarationMethod MethodDeclaration |
  StructMemberDeclarationProperty PropertyDeclaration |
  StructMemberDeclarationEvent EventDeclaration |
  StructMemberDeclarationIndexer IndexerDeclaration |
  StructMemberDeclarationOperator OperatorDeclaration |
  StructMemberDeclarationConstructor ConstructorDeclaration |
  StructMemberDeclarationStaticConstructor StaticConstructorDeclaration |
  StructMemberDeclarationType TypeDeclaration |
  StructMemberDeclarationFixedSizeBuffer FixedSizeBufferDeclaration
  deriving (Eq, Ord, Read, Show)

_StructMemberDeclaration = (Core.Name "hydra/ext/csharp/syntax.StructMemberDeclaration")

_StructMemberDeclaration_constant = (Core.Name "constant")

_StructMemberDeclaration_field = (Core.Name "field")

_StructMemberDeclaration_method = (Core.Name "method")

_StructMemberDeclaration_property = (Core.Name "property")

_StructMemberDeclaration_event = (Core.Name "event")

_StructMemberDeclaration_indexer = (Core.Name "indexer")

_StructMemberDeclaration_operator = (Core.Name "operator")

_StructMemberDeclaration_constructor = (Core.Name "constructor")

_StructMemberDeclaration_staticConstructor = (Core.Name "staticConstructor")

_StructMemberDeclaration_type = (Core.Name "type")

_StructMemberDeclaration_fixedSizeBuffer = (Core.Name "fixedSizeBuffer")

newtype ArrayInitializer = 
  ArrayInitializer {
    unArrayInitializer :: [VariableInitializer]}
  deriving (Eq, Ord, Read, Show)

_ArrayInitializer = (Core.Name "hydra/ext/csharp/syntax.ArrayInitializer")

data VariableInitializer = 
  VariableInitializerExpression Expression |
  VariableInitializerArray ArrayInitializer
  deriving (Eq, Ord, Read, Show)

_VariableInitializer = (Core.Name "hydra/ext/csharp/syntax.VariableInitializer")

_VariableInitializer_expression = (Core.Name "expression")

_VariableInitializer_array = (Core.Name "array")

data InterfaceDeclaration = 
  InterfaceDeclaration {
    interfaceDeclarationAttributes :: (Maybe Attributes),
    interfaceDeclarationModifiers :: [InterfaceModifier],
    interfaceDeclarationPartial :: Bool,
    interfaceDeclarationName :: Identifier,
    interfaceDeclarationParameters :: (Maybe VariantTypeParameters),
    interfaceDeclarationBase :: [InterfaceType],
    interfaceDeclarationConstraints :: [TypeParameterConstraintsClause],
    interfaceDeclarationBody :: [InterfaceMemberDeclaration]}
  deriving (Eq, Ord, Read, Show)

_InterfaceDeclaration = (Core.Name "hydra/ext/csharp/syntax.InterfaceDeclaration")

_InterfaceDeclaration_attributes = (Core.Name "attributes")

_InterfaceDeclaration_modifiers = (Core.Name "modifiers")

_InterfaceDeclaration_partial = (Core.Name "partial")

_InterfaceDeclaration_name = (Core.Name "name")

_InterfaceDeclaration_parameters = (Core.Name "parameters")

_InterfaceDeclaration_base = (Core.Name "base")

_InterfaceDeclaration_constraints = (Core.Name "constraints")

_InterfaceDeclaration_body = (Core.Name "body")

data InterfaceModifier = 
  InterfaceModifierNew  |
  InterfaceModifierPublic  |
  InterfaceModifierProtected  |
  InterfaceModifierInternal  |
  InterfaceModifierPrivate  |
  InterfaceModifierUnsafe 
  deriving (Eq, Ord, Read, Show)

_InterfaceModifier = (Core.Name "hydra/ext/csharp/syntax.InterfaceModifier")

_InterfaceModifier_new = (Core.Name "new")

_InterfaceModifier_public = (Core.Name "public")

_InterfaceModifier_protected = (Core.Name "protected")

_InterfaceModifier_internal = (Core.Name "internal")

_InterfaceModifier_private = (Core.Name "private")

_InterfaceModifier_unsafe = (Core.Name "unsafe")

newtype VariantTypeParameters = 
  VariantTypeParameters {
    unVariantTypeParameters :: [VariantTypeParameter]}
  deriving (Eq, Ord, Read, Show)

_VariantTypeParameters = (Core.Name "hydra/ext/csharp/syntax.VariantTypeParameters")

data VariantTypeParameter = 
  VariantTypeParameter {
    variantTypeParameterAttributes :: (Maybe Attributes),
    variantTypeParameterVariance :: (Maybe VarianceAnnotation),
    variantTypeParameterParameter :: TypeParameter}
  deriving (Eq, Ord, Read, Show)

_VariantTypeParameter = (Core.Name "hydra/ext/csharp/syntax.VariantTypeParameter")

_VariantTypeParameter_attributes = (Core.Name "attributes")

_VariantTypeParameter_variance = (Core.Name "variance")

_VariantTypeParameter_parameter = (Core.Name "parameter")

data VarianceAnnotation = 
  VarianceAnnotationIn  |
  VarianceAnnotationOut 
  deriving (Eq, Ord, Read, Show)

_VarianceAnnotation = (Core.Name "hydra/ext/csharp/syntax.VarianceAnnotation")

_VarianceAnnotation_in = (Core.Name "in")

_VarianceAnnotation_out = (Core.Name "out")

data InterfaceMemberDeclaration = 
  InterfaceMemberDeclarationMethod InterfaceMethodDeclaration |
  InterfaceMemberDeclarationProperty InterfacePropertyDeclaration |
  InterfaceMemberDeclarationEvent InterfaceEventDeclaration |
  InterfaceMemberDeclarationIndexer InterfaceIndexerDeclaration
  deriving (Eq, Ord, Read, Show)

_InterfaceMemberDeclaration = (Core.Name "hydra/ext/csharp/syntax.InterfaceMemberDeclaration")

_InterfaceMemberDeclaration_method = (Core.Name "method")

_InterfaceMemberDeclaration_property = (Core.Name "property")

_InterfaceMemberDeclaration_event = (Core.Name "event")

_InterfaceMemberDeclaration_indexer = (Core.Name "indexer")

data InterfaceMethodDeclaration = 
  InterfaceMethodDeclaration {
    interfaceMethodDeclarationAttributes :: (Maybe Attributes),
    interfaceMethodDeclarationNew :: Bool,
    interfaceMethodDeclarationReturnType :: ReturnType,
    interfaceMethodDeclarationRefKind :: (Maybe RefKind),
    interfaceMethodDeclarationHeader :: InterfaceMethodHeader}
  deriving (Eq, Ord, Read, Show)

_InterfaceMethodDeclaration = (Core.Name "hydra/ext/csharp/syntax.InterfaceMethodDeclaration")

_InterfaceMethodDeclaration_attributes = (Core.Name "attributes")

_InterfaceMethodDeclaration_new = (Core.Name "new")

_InterfaceMethodDeclaration_returnType = (Core.Name "returnType")

_InterfaceMethodDeclaration_refKind = (Core.Name "refKind")

_InterfaceMethodDeclaration_header = (Core.Name "header")

data InterfaceMethodHeader = 
  InterfaceMethodHeader {
    interfaceMethodHeaderName :: Identifier,
    interfaceMethodHeaderParameters :: (Maybe FormalParameterList),
    interfaceMethodHeaderTypeParameters :: (Maybe TypeParameterList),
    interfaceMethodHeaderConstraints :: [TypeParameterConstraintsClause]}
  deriving (Eq, Ord, Read, Show)

_InterfaceMethodHeader = (Core.Name "hydra/ext/csharp/syntax.InterfaceMethodHeader")

_InterfaceMethodHeader_name = (Core.Name "name")

_InterfaceMethodHeader_parameters = (Core.Name "parameters")

_InterfaceMethodHeader_typeParameters = (Core.Name "typeParameters")

_InterfaceMethodHeader_constraints = (Core.Name "constraints")

data InterfacePropertyDeclaration = 
  InterfacePropertyDeclaration {
    interfacePropertyDeclarationAttributes :: (Maybe Attributes),
    interfacePropertyDeclarationNew :: Bool,
    interfacePropertyDeclarationRefKind :: (Maybe RefKind),
    interfacePropertyDeclarationType :: Type,
    interfacePropertyDeclarationName :: Identifier,
    interfacePropertyDeclarationAccessors :: InterfaceAccessors}
  deriving (Eq, Ord, Read, Show)

_InterfacePropertyDeclaration = (Core.Name "hydra/ext/csharp/syntax.InterfacePropertyDeclaration")

_InterfacePropertyDeclaration_attributes = (Core.Name "attributes")

_InterfacePropertyDeclaration_new = (Core.Name "new")

_InterfacePropertyDeclaration_refKind = (Core.Name "refKind")

_InterfacePropertyDeclaration_type = (Core.Name "type")

_InterfacePropertyDeclaration_name = (Core.Name "name")

_InterfacePropertyDeclaration_accessors = (Core.Name "accessors")

data InterfaceAccessors = 
  InterfaceAccessors {
    interfaceAccessorsAttributes :: (Maybe Attributes),
    interfaceAccessorsGet :: (Maybe Attributes),
    interfaceAccessorsSet :: (Maybe Attributes)}
  deriving (Eq, Ord, Read, Show)

_InterfaceAccessors = (Core.Name "hydra/ext/csharp/syntax.InterfaceAccessors")

_InterfaceAccessors_attributes = (Core.Name "attributes")

_InterfaceAccessors_get = (Core.Name "get")

_InterfaceAccessors_set = (Core.Name "set")

data InterfaceEventDeclaration = 
  InterfaceEventDeclaration {
    interfaceEventDeclarationAttributes :: (Maybe Attributes),
    interfaceEventDeclarationNew :: Bool,
    interfaceEventDeclarationType :: Type,
    interfaceEventDeclarationName :: Identifier}
  deriving (Eq, Ord, Read, Show)

_InterfaceEventDeclaration = (Core.Name "hydra/ext/csharp/syntax.InterfaceEventDeclaration")

_InterfaceEventDeclaration_attributes = (Core.Name "attributes")

_InterfaceEventDeclaration_new = (Core.Name "new")

_InterfaceEventDeclaration_type = (Core.Name "type")

_InterfaceEventDeclaration_name = (Core.Name "name")

data InterfaceIndexerDeclaration = 
  InterfaceIndexerDeclaration {
    interfaceIndexerDeclarationAttributes :: (Maybe Attributes),
    interfaceIndexerDeclarationNew :: Bool,
    interfaceIndexerDeclarationRefKind :: (Maybe RefKind),
    interfaceIndexerDeclarationType :: Type,
    interfaceIndexerDeclarationParameters :: FormalParameterList,
    interfaceIndexerDeclarationAccessors :: InterfaceAccessors}
  deriving (Eq, Ord, Read, Show)

_InterfaceIndexerDeclaration = (Core.Name "hydra/ext/csharp/syntax.InterfaceIndexerDeclaration")

_InterfaceIndexerDeclaration_attributes = (Core.Name "attributes")

_InterfaceIndexerDeclaration_new = (Core.Name "new")

_InterfaceIndexerDeclaration_refKind = (Core.Name "refKind")

_InterfaceIndexerDeclaration_type = (Core.Name "type")

_InterfaceIndexerDeclaration_parameters = (Core.Name "parameters")

_InterfaceIndexerDeclaration_accessors = (Core.Name "accessors")

data EnumDeclaration = 
  EnumDeclaration {
    enumDeclarationAttributes :: (Maybe Attributes),
    enumDeclarationModifiers :: [EnumModifier],
    enumDeclarationName :: Identifier,
    enumDeclarationBase :: (Maybe EnumBase),
    enumDeclarationBody :: (Maybe EnumBody)}
  deriving (Eq, Ord, Read, Show)

_EnumDeclaration = (Core.Name "hydra/ext/csharp/syntax.EnumDeclaration")

_EnumDeclaration_attributes = (Core.Name "attributes")

_EnumDeclaration_modifiers = (Core.Name "modifiers")

_EnumDeclaration_name = (Core.Name "name")

_EnumDeclaration_base = (Core.Name "base")

_EnumDeclaration_body = (Core.Name "body")

data EnumBase = 
  EnumBaseType IntegralType |
  EnumBaseName TypeName
  deriving (Eq, Ord, Read, Show)

_EnumBase = (Core.Name "hydra/ext/csharp/syntax.EnumBase")

_EnumBase_type = (Core.Name "type")

_EnumBase_name = (Core.Name "name")

newtype EnumBody = 
  EnumBody {
    unEnumBody :: [EnumMemberDeclaration]}
  deriving (Eq, Ord, Read, Show)

_EnumBody = (Core.Name "hydra/ext/csharp/syntax.EnumBody")

data EnumModifier = 
  EnumModifierNew  |
  EnumModifierPublic  |
  EnumModifierProtected  |
  EnumModifierInternal  |
  EnumModifierPrivate 
  deriving (Eq, Ord, Read, Show)

_EnumModifier = (Core.Name "hydra/ext/csharp/syntax.EnumModifier")

_EnumModifier_new = (Core.Name "new")

_EnumModifier_public = (Core.Name "public")

_EnumModifier_protected = (Core.Name "protected")

_EnumModifier_internal = (Core.Name "internal")

_EnumModifier_private = (Core.Name "private")

data EnumMemberDeclaration = 
  EnumMemberDeclaration {
    enumMemberDeclarationAttributes :: (Maybe Attributes),
    enumMemberDeclarationName :: Identifier,
    enumMemberDeclarationValue :: (Maybe ConstantExpression)}
  deriving (Eq, Ord, Read, Show)

_EnumMemberDeclaration = (Core.Name "hydra/ext/csharp/syntax.EnumMemberDeclaration")

_EnumMemberDeclaration_attributes = (Core.Name "attributes")

_EnumMemberDeclaration_name = (Core.Name "name")

_EnumMemberDeclaration_value = (Core.Name "value")

data DelegateDeclaration = 
  DelegateDeclaration {
    delegateDeclarationAttributes :: (Maybe Attributes),
    delegateDeclarationModifiers :: [DelegateModifier],
    delegateDeclarationReturnType :: ReturnType,
    delegateDeclarationRefKind :: (Maybe RefKind),
    delegateDeclarationRefReturnType :: (Maybe Type),
    delegateDeclarationHeader :: DelegateHeader}
  deriving (Eq, Ord, Read, Show)

_DelegateDeclaration = (Core.Name "hydra/ext/csharp/syntax.DelegateDeclaration")

_DelegateDeclaration_attributes = (Core.Name "attributes")

_DelegateDeclaration_modifiers = (Core.Name "modifiers")

_DelegateDeclaration_returnType = (Core.Name "returnType")

_DelegateDeclaration_refKind = (Core.Name "refKind")

_DelegateDeclaration_refReturnType = (Core.Name "refReturnType")

_DelegateDeclaration_header = (Core.Name "header")

data DelegateHeader = 
  DelegateHeader {
    delegateHeaderName :: Identifier,
    delegateHeaderTypeParameters :: (Maybe VariantTypeParameters),
    delegateHeaderParameters :: (Maybe FormalParameterList),
    delegateHeaderConstraints :: [TypeParameterConstraintsClause]}
  deriving (Eq, Ord, Read, Show)

_DelegateHeader = (Core.Name "hydra/ext/csharp/syntax.DelegateHeader")

_DelegateHeader_name = (Core.Name "name")

_DelegateHeader_typeParameters = (Core.Name "typeParameters")

_DelegateHeader_parameters = (Core.Name "parameters")

_DelegateHeader_constraints = (Core.Name "constraints")

data DelegateModifier = 
  DelegateModifierNew  |
  DelegateModifierPublic  |
  DelegateModifierProtected  |
  DelegateModifierInternal  |
  DelegateModifierPrivate  |
  DelegateModifierUnsafe 
  deriving (Eq, Ord, Read, Show)

_DelegateModifier = (Core.Name "hydra/ext/csharp/syntax.DelegateModifier")

_DelegateModifier_new = (Core.Name "new")

_DelegateModifier_public = (Core.Name "public")

_DelegateModifier_protected = (Core.Name "protected")

_DelegateModifier_internal = (Core.Name "internal")

_DelegateModifier_private = (Core.Name "private")

_DelegateModifier_unsafe = (Core.Name "unsafe")

data GlobalAttributeSection = 
  GlobalAttributeSection {
    globalAttributeSectionTarget :: Identifier,
    globalAttributeSectionAttributes :: AttributeList}
  deriving (Eq, Ord, Read, Show)

_GlobalAttributeSection = (Core.Name "hydra/ext/csharp/syntax.GlobalAttributeSection")

_GlobalAttributeSection_target = (Core.Name "target")

_GlobalAttributeSection_attributes = (Core.Name "attributes")

newtype Attributes = 
  Attributes {
    unAttributes :: [AttributeSection]}
  deriving (Eq, Ord, Read, Show)

_Attributes = (Core.Name "hydra/ext/csharp/syntax.Attributes")

data AttributeSection = 
  AttributeSection {
    attributeSectionTarget :: (Maybe AttributeTarget),
    attributeSectionAttributes :: AttributeList}
  deriving (Eq, Ord, Read, Show)

_AttributeSection = (Core.Name "hydra/ext/csharp/syntax.AttributeSection")

_AttributeSection_target = (Core.Name "target")

_AttributeSection_attributes = (Core.Name "attributes")

data AttributeTarget = 
  AttributeTargetIdentifier Identifier |
  AttributeTargetKeyword Keyword
  deriving (Eq, Ord, Read, Show)

_AttributeTarget = (Core.Name "hydra/ext/csharp/syntax.AttributeTarget")

_AttributeTarget_identifier = (Core.Name "identifier")

_AttributeTarget_keyword = (Core.Name "keyword")

newtype AttributeList = 
  AttributeList {
    unAttributeList :: [Attribute]}
  deriving (Eq, Ord, Read, Show)

_AttributeList = (Core.Name "hydra/ext/csharp/syntax.AttributeList")

data Attribute = 
  Attribute {
    attributeName :: AttributeName,
    attributeArguments :: (Maybe AttributeArguments)}
  deriving (Eq, Ord, Read, Show)

_Attribute = (Core.Name "hydra/ext/csharp/syntax.Attribute")

_Attribute_name = (Core.Name "name")

_Attribute_arguments = (Core.Name "arguments")

newtype AttributeName = 
  AttributeName {
    unAttributeName :: TypeName}
  deriving (Eq, Ord, Read, Show)

_AttributeName = (Core.Name "hydra/ext/csharp/syntax.AttributeName")

data AttributeArguments = 
  AttributeArguments {
    attributeArgumentsPositonal :: (Maybe PositionalArgumentList),
    attributeArgumentsNamed :: (Maybe NamedArgumentList)}
  deriving (Eq, Ord, Read, Show)

_AttributeArguments = (Core.Name "hydra/ext/csharp/syntax.AttributeArguments")

_AttributeArguments_positonal = (Core.Name "positonal")

_AttributeArguments_named = (Core.Name "named")

newtype PositionalArgumentList = 
  PositionalArgumentList {
    unPositionalArgumentList :: [PositionalArgument]}
  deriving (Eq, Ord, Read, Show)

_PositionalArgumentList = (Core.Name "hydra/ext/csharp/syntax.PositionalArgumentList")

data PositionalArgument = 
  PositionalArgument {
    positionalArgumentName :: (Maybe Identifier),
    positionalArgumentValue :: AttributeArgumentExpression}
  deriving (Eq, Ord, Read, Show)

_PositionalArgument = (Core.Name "hydra/ext/csharp/syntax.PositionalArgument")

_PositionalArgument_name = (Core.Name "name")

_PositionalArgument_value = (Core.Name "value")

newtype NamedArgumentList = 
  NamedArgumentList {
    unNamedArgumentList :: [NamedArgument]}
  deriving (Eq, Ord, Read, Show)

_NamedArgumentList = (Core.Name "hydra/ext/csharp/syntax.NamedArgumentList")

data NamedArgument = 
  NamedArgument {
    namedArgumentName :: Identifier,
    namedArgumentValue :: AttributeArgumentExpression}
  deriving (Eq, Ord, Read, Show)

_NamedArgument = (Core.Name "hydra/ext/csharp/syntax.NamedArgument")

_NamedArgument_name = (Core.Name "name")

_NamedArgument_value = (Core.Name "value")

newtype AttributeArgumentExpression = 
  AttributeArgumentExpression {
    unAttributeArgumentExpression :: NonAssignmentExpression}
  deriving (Eq, Ord, Read, Show)

_AttributeArgumentExpression = (Core.Name "hydra/ext/csharp/syntax.AttributeArgumentExpression")

data PointerType = 
  PointerTypeValueType (Maybe ValueType) |
  PointerTypePointerDepth Int
  deriving (Eq, Ord, Read, Show)

_PointerType = (Core.Name "hydra/ext/csharp/syntax.PointerType")

_PointerType_valueType = (Core.Name "valueType")

_PointerType_pointerDepth = (Core.Name "pointerDepth")

data PointerMemberAccess = 
  PointerMemberAccess {
    pointerMemberAccessPointer :: PrimaryExpression,
    pointerMemberAccessMember :: Identifier,
    pointerMemberAccessTypeArguments :: (Maybe TypeArgumentList)}
  deriving (Eq, Ord, Read, Show)

_PointerMemberAccess = (Core.Name "hydra/ext/csharp/syntax.PointerMemberAccess")

_PointerMemberAccess_pointer = (Core.Name "pointer")

_PointerMemberAccess_member = (Core.Name "member")

_PointerMemberAccess_typeArguments = (Core.Name "typeArguments")

data PointerElementAccess = 
  PointerElementAccess {
    pointerElementAccessPointer :: PrimaryNoArrayCreationExpression,
    pointerElementAccessIndex :: Expression}
  deriving (Eq, Ord, Read, Show)

_PointerElementAccess = (Core.Name "hydra/ext/csharp/syntax.PointerElementAccess")

_PointerElementAccess_pointer = (Core.Name "pointer")

_PointerElementAccess_index = (Core.Name "index")

data FixedStatement = 
  FixedStatement {
    fixedStatementPointerType :: PointerType,
    fixedStatementDeclarators :: [FixedPointerDeclarator],
    fixedStatementStatement :: EmbeddedStatement}
  deriving (Eq, Ord, Read, Show)

_FixedStatement = (Core.Name "hydra/ext/csharp/syntax.FixedStatement")

_FixedStatement_pointerType = (Core.Name "pointerType")

_FixedStatement_declarators = (Core.Name "declarators")

_FixedStatement_statement = (Core.Name "statement")

data FixedPointerDeclarator = 
  FixedPointerDeclaratorReference VariableReference |
  FixedPointerDeclaratorExpression Expression
  deriving (Eq, Ord, Read, Show)

_FixedPointerDeclarator = (Core.Name "hydra/ext/csharp/syntax.FixedPointerDeclarator")

_FixedPointerDeclarator_reference = (Core.Name "reference")

_FixedPointerDeclarator_expression = (Core.Name "expression")

data FixedSizeBufferDeclaration = 
  FixedSizeBufferDeclaration {
    fixedSizeBufferDeclarationAttributes :: (Maybe Attributes),
    fixedSizeBufferDeclarationModifiers :: [FixedSizeBufferModifier],
    fixedSizeBufferDeclarationElementType :: Type,
    fixedSizeBufferDeclarationDeclarators :: [FixedSizeBufferDeclarator]}
  deriving (Eq, Ord, Read, Show)

_FixedSizeBufferDeclaration = (Core.Name "hydra/ext/csharp/syntax.FixedSizeBufferDeclaration")

_FixedSizeBufferDeclaration_attributes = (Core.Name "attributes")

_FixedSizeBufferDeclaration_modifiers = (Core.Name "modifiers")

_FixedSizeBufferDeclaration_elementType = (Core.Name "elementType")

_FixedSizeBufferDeclaration_declarators = (Core.Name "declarators")

data FixedSizeBufferModifier = 
  FixedSizeBufferModifierNew  |
  FixedSizeBufferModifierPublic  |
  FixedSizeBufferModifierInternal  |
  FixedSizeBufferModifierPrivate  |
  FixedSizeBufferModifierUnsafe 
  deriving (Eq, Ord, Read, Show)

_FixedSizeBufferModifier = (Core.Name "hydra/ext/csharp/syntax.FixedSizeBufferModifier")

_FixedSizeBufferModifier_new = (Core.Name "new")

_FixedSizeBufferModifier_public = (Core.Name "public")

_FixedSizeBufferModifier_internal = (Core.Name "internal")

_FixedSizeBufferModifier_private = (Core.Name "private")

_FixedSizeBufferModifier_unsafe = (Core.Name "unsafe")

data FixedSizeBufferDeclarator = 
  FixedSizeBufferDeclarator {
    fixedSizeBufferDeclaratorName :: Identifier,
    fixedSizeBufferDeclaratorSize :: ConstantExpression}
  deriving (Eq, Ord, Read, Show)

_FixedSizeBufferDeclarator = (Core.Name "hydra/ext/csharp/syntax.FixedSizeBufferDeclarator")

_FixedSizeBufferDeclarator_name = (Core.Name "name")

_FixedSizeBufferDeclarator_size = (Core.Name "size")