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

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

-- | 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.Csharp.Syntax where

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

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

_Identifier = Core.Name "hydra.csharp.syntax.Identifier"

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

_Keyword = Core.Name "hydra.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.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.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.csharp.syntax.NamespaceName"

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

_TypeName = Core.Name "hydra.csharp.syntax.TypeName"

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

_NamespaceOrTypeName = Core.Name "hydra.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.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.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.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.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.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.csharp.syntax.InterfaceType"

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

_ArrayType = Core.Name "hydra.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.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.csharp.syntax.RankSpecifier"

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

_DelegateType = Core.Name "hydra.csharp.syntax.DelegateType"

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

_ValueType = Core.Name "hydra.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.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.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.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.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.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.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.csharp.syntax.TupleType"

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

_TupleTypeElement = Core.Name "hydra.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.csharp.syntax.EnumType"

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

_TypeArgumentList = Core.Name "hydra.csharp.syntax.TypeArgumentList"

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

_TypeParameter = Core.Name "hydra.csharp.syntax.TypeParameter"

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

_UnmanagedType = Core.Name "hydra.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.csharp.syntax.VariableReference"

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

_Pattern = Core.Name "hydra.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.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.csharp.syntax.Designation"

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

_ArgumentList = Core.Name "hydra.csharp.syntax.ArgumentList"

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

_Argument = Core.Name "hydra.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.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.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.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.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.csharp.syntax.InterpolatedRegularStringExpression"

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

_RegularInterpolation = Core.Name "hydra.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.csharp.syntax.InterpolatedVerbatimStringExpression"

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

_VerbatimInterpolation = Core.Name "hydra.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.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.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.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.csharp.syntax.DeconstructionTuple"

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

_DeconstructionElement = Core.Name "hydra.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.csharp.syntax.ExpressionList"

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

_ArrayCreationExpression = Core.Name "hydra.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.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.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.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.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.csharp.syntax.MemberDeclaratorList"

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

_MemberDeclarator = Core.Name "hydra.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.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.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.csharp.syntax.UnboundTypeName"

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

_UnboundTypeNamePart = Core.Name "hydra.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.csharp.syntax.ConstantExpression"

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

_BooleanExpression = Core.Name "hydra.csharp.syntax.BooleanExpression"

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

_Statement = Core.Name "hydra.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.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.csharp.syntax.Block"

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

_LabeledStatement = Core.Name "hydra.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.csharp.syntax.YieldStatement"

_YieldStatement_return = Core.Name "return"

_YieldStatement_break = Core.Name "break"

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

_CompilationUnit = Core.Name "hydra.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 :: QualifiedIdentifier,
    namespaceDeclarationBody :: NamespaceBody}
  deriving (Eq, Ord, Read, Show)

_NamespaceDeclaration = Core.Name "hydra.csharp.syntax.NamespaceDeclaration"

_NamespaceDeclaration_name = Core.Name "name"

_NamespaceDeclaration_body = Core.Name "body"

newtype QualifiedIdentifier =
  QualifiedIdentifier {
    unQualifiedIdentifier :: [Identifier]}
  deriving (Eq, Ord, Read, Show)

_QualifiedIdentifier = Core.Name "hydra.csharp.syntax.QualifiedIdentifier"

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

_NamespaceBody = Core.Name "hydra.csharp.syntax.NamespaceBody"

_NamespaceBody_externs = Core.Name "externs"

_NamespaceBody_usings = Core.Name "usings"

_NamespaceBody_members = Core.Name "members"

newtype ExternAliasDirective =
  ExternAliasDirective {
    unExternAliasDirective :: Identifier}
  deriving (Eq, Ord, Read, Show)

_ExternAliasDirective = Core.Name "hydra.csharp.syntax.ExternAliasDirective"

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

_UsingDirective = Core.Name "hydra.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.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.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.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.csharp.syntax.QualifiedAliasMember"

_QualifiedAliasMember_alias = Core.Name "alias"

_QualifiedAliasMember_member = Core.Name "member"

_QualifiedAliasMember_arguments = Core.Name "arguments"

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

_ClassDeclaration = Core.Name "hydra.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.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.csharp.syntax.TypeParameterList"

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

_TypeParameterPart = Core.Name "hydra.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.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.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.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.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.csharp.syntax.SecondaryConstraints"

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

_SecondaryConstraint = Core.Name "hydra.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.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.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.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.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.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.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.csharp.syntax.VariableDeclarators"

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

_VariableDeclarator = Core.Name "hydra.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.csharp.syntax.ArrayInitializer"

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

_VariableInitializer = Core.Name "hydra.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.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.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.csharp.syntax.VariantTypeParameters"

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

_VariantTypeParameter = Core.Name "hydra.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.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.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.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.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.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.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.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.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.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.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.csharp.syntax.EnumBody"

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

_EnumModifier = Core.Name "hydra.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.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.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.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.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.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.csharp.syntax.Attributes"

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

_AttributeSection = Core.Name "hydra.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.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.csharp.syntax.AttributeList"

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

_Attribute = Core.Name "hydra.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.csharp.syntax.AttributeName"

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

_AttributeArguments = Core.Name "hydra.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.csharp.syntax.PositionalArgumentList"

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

_PositionalArgument = Core.Name "hydra.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.csharp.syntax.NamedArgumentList"

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

_NamedArgument = Core.Name "hydra.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.csharp.syntax.AttributeArgumentExpression"

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

_PointerType = Core.Name "hydra.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.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.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.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.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.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.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.csharp.syntax.FixedSizeBufferDeclarator"

_FixedSizeBufferDeclarator_name = Core.Name "name"

_FixedSizeBufferDeclarator_size = Core.Name "size"