hydra-ext-0.17.4: 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

-- | The body of a property or indexer accessor: a block, an expression, or empty (abstract).
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"

-- | A single get or set accessor, with optional attributes and an access modifier.
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"

-- | The get and/or set accessors of a standard (non-ref-returning) property.
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"

-- | An access modifier restricting a get or set accessor beyond the property's own accessibility.
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"

-- | An event declaration using explicit add/remove accessor syntax.
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"

-- | The add or remove accessor body of an event declaration.
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"

-- | A simple multiplicative expression or a binary addition/subtraction expression.
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"

-- | The plus or minus operator used in an additive expression.
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"

-- | A simple equality expression or a binary bitwise-AND expression.
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"

-- | The body of an anonymous function: a null-conditional invocation, expression, ref, or block.
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"

-- | A ref, out, or in modifier on an explicit anonymous function parameter.
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"

-- | The parameter list of a lambda expression, either explicitly or implicitly typed.
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"

-- | A delegate expression created with the anonymous method syntax (delegate(...) { ... }).
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"

-- | A single argument in an argument list, with an optional name for named arguments.
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"

-- | A non-empty, comma-separated list of arguments passed to a member or delegate invocation.
newtype ArgumentList =
  ArgumentList {
    unArgumentList :: [Argument]}
  deriving (Eq, Ord, Read, Show)

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

-- | The value portion of an argument: an expression, or a ref/in/out variable reference.
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"

-- | An expression that creates a new array, in any of its three creation-syntax forms.
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"

-- | A brace-delimited list of variable initializers used to populate an array.
newtype ArrayInitializer =
  ArrayInitializer {
    unArrayInitializer :: [VariableInitializer]}
  deriving (Eq, Ord, Read, Show)

_ArrayInitializer = Core.Name "hydra.csharp.syntax.ArrayInitializer"

-- | An array type formed from a non-array element type and one or more rank specifiers.
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"

-- | Array creation using an explicit array type together with an array 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"

-- | An 'as' expression that attempts a type conversion, yielding null on failure.
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"

-- | An assignment expression: a target, an assignment operator, and a right-hand expression.
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"

-- | A member declarator of the form 'name = expression' in an anonymous object creation.
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"

-- | The simple assignment operator or one of the compound assignment operators.
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"

-- | A single attribute, consisting of an attribute name and optional constructor/named arguments.
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"

-- | An expression usable as an attribute argument (a compile-time constant expression).
newtype AttributeArgumentExpression =
  AttributeArgumentExpression {
    unAttributeArgumentExpression :: NonAssignmentExpression}
  deriving (Eq, Ord, Read, Show)

_AttributeArgumentExpression = Core.Name "hydra.csharp.syntax.AttributeArgumentExpression"

-- | The positional and named argument lists supplied to an attribute.
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"

-- | A non-empty, comma-separated list of attributes within a single attribute section.
newtype AttributeList =
  AttributeList {
    unAttributeList :: [Attribute]}
  deriving (Eq, Ord, Read, Show)

_AttributeList = Core.Name "hydra.csharp.syntax.AttributeList"

-- | The type name referenced by an attribute, resolved against types ending in the suffix Attribute.
newtype AttributeName =
  AttributeName {
    unAttributeName :: TypeName}
  deriving (Eq, Ord, Read, Show)

_AttributeName = Core.Name "hydra.csharp.syntax.AttributeName"

-- | A bracketed attribute section, with an optional target specifier, attached to a declaration.
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"

-- | The target specifier of an attribute section (e.g. assembly, module, return, field).
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"

-- | A non-empty sequence of attribute sections attached to a single declaration.
newtype Attributes =
  Attributes {
    unAttributes :: [AttributeSection]}
  deriving (Eq, Ord, Read, Show)

_Attributes = Core.Name "hydra.csharp.syntax.Attributes"

-- | A 'base' access expression, either invoking a base member or indexing via base[args].
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"

-- | A 'base.member' access, with an optional list of type 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"

-- | A binary addition or subtraction expression with a left operand, operator, and right operand.
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"

-- | A binary bitwise-AND expression (&) over two operand expressions.
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"

-- | A binary conditional-AND expression (&&) over two operand expressions.
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"

-- | A binary conditional-OR expression (||) over two operand expressions.
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"

-- | A binary equality or inequality comparison expression.
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"

-- | A binary bitwise exclusive-OR expression (^) over two operand expressions.
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"

-- | A binary bitwise inclusive-OR expression (|) over two operand expressions.
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"

-- | A binary multiplication, division, or remainder expression.
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"

-- | A binary null-coalescing expression (??) over two operand expressions.
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"

-- | The declarator for a user-defined binary operator overload, naming its two parameters.
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"

-- | A binary relational comparison expression (<, >, <=, or >=).
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"

-- | A binary left-shift or right-shift expression.
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"

-- | A brace-delimited sequence of statements forming a single compound statement.
newtype Block =
  Block {
    unBlock :: [Statement]}
  deriving (Eq, Ord, Read, Show)

_Block = Core.Name "hydra.csharp.syntax.Block"

-- | A property body given as get/set accessor declarations, with an optional initializer.
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"

-- | An expression required to have (or be convertible to) type bool, such as an if condition.
newtype BooleanExpression =
  BooleanExpression {
    unBooleanExpression :: Expression}
  deriving (Eq, Ord, Read, Show)

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

-- | An explicit type-cast expression applied to a unary expression.
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"

-- | The catch clauses of a try statement: one or more specific clauses, or a single general clause.
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"

-- | The base class and/or implemented interfaces listed in a class declaration's base-list.
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"

-- | The brace-delimited sequence of member declarations that make up a class.
newtype ClassBody =
  ClassBody {
    unClassBody :: [ClassMemberDeclaration]}
  deriving (Eq, Ord, Read, Show)

_ClassBody = Core.Name "hydra.csharp.syntax.ClassBody"

-- | A C# class declaration, including its modifiers, type parameters, base list, and body.
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"

-- | Any member that can appear in a class body: field, method, property, event, and so on.
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"

-- | A modifier keyword on a class declaration, such as public, abstract, sealed, or static.
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"

-- | A reference to a class type: a named type, or the predefined 'object' or 'string' types.
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"

-- | The root of a C# source file: extern aliases, using directives, attributes, and type members.
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"

-- | A simple inclusive-OR expression or a binary conditional-AND (&&) expression.
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"

-- | The ternary conditional expression, in its simple, ref-conditional, or fallthrough forms.
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"

-- | A simple conditional-AND expression or a binary conditional-OR (||) expression.
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"

-- | A 'const' field declaration with its modifiers, type, and one or more declarators.
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"

-- | A single 'identifier = expression' pair within a constant declaration.
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"

-- | An expression that is required to be evaluable at compile time.
newtype ConstantExpression =
  ConstantExpression {
    unConstantExpression :: Expression}
  deriving (Eq, Ord, Read, Show)

_ConstantExpression = Core.Name "hydra.csharp.syntax.ConstantExpression"

-- | An access modifier (new, public, protected, internal, or private) on a constant declaration.
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"

-- | The body of an instance constructor: a block, expression body, or empty (extern) body.
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"

-- | An instance constructor declaration, including its declarator and body.
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"

-- | A constructor's name, parameter list, and optional base/this initializer.
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"

-- | A ': base(...)' or ': this(...)' initializer invoked before a constructor body runs.
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"

-- | An access or extern/unsafe modifier on an instance constructor declaration.
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"

-- | Whether a user-defined conversion operator is implicit or explicit.
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"

-- | The declarator for a user-defined implicit or explicit conversion operator.
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"

-- | An inline variable declaration used as an expression, such as an out-variable declaration.
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"

-- | A pattern that tests an expression's type and, on success, binds it to a designation.
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"

-- | A local variable, local constant, or local function declaration 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"

-- | One element of a deconstruction pattern: a nested tuple or a bound identifier.
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"

-- | A tuple deconstruction pattern used on the left-hand side of a deconstructing assignment.
newtype DeconstructionTuple =
  DeconstructionTuple {
    unDeconstructionTuple :: [DeconstructionElement]}
  deriving (Eq, Ord, Read, Show)

_DeconstructionTuple = Core.Name "hydra.csharp.syntax.DeconstructionTuple"

-- | A 'default(T)' expression, or the type-inferred 'default' literal.
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"

-- | An expression that creates a delegate instance from a method group or lambda.
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"

-- | A delegate type declaration, naming its return type, ref kind, and parameter list.
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"

-- | The name, type parameters, formal parameters, and constraints of a delegate declaration.
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"

-- | An access or unsafe modifier on a delegate type declaration.
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"

-- | A reference to a delegate type by its type name.
newtype DelegateType =
  DelegateType {
    unDelegateType :: TypeName}
  deriving (Eq, Ord, Read, Show)

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

-- | A member access, element access, or invocation chained after a null-conditional operator.
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"

-- | A member identifier and optional type arguments chained after a null-conditional access.
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"

-- | A simple identifier binding introduced by a pattern, such as in a declaration pattern.
newtype Designation =
  Designation {
    unDesignation :: Identifier}
  deriving (Eq, Ord, Read, Show)

_Designation = Core.Name "hydra.csharp.syntax.Designation"

-- | A do-while iteration statement that executes its body at least once.
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"

-- | An indexer access expression applying an argument list to a primary expression.
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"

-- | A single element of a collection initializer: one expression, or a nested element list.
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"

-- | A statement nested inside another statement, excluding labeled and declaration statements.
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"

-- | The optional explicit underlying integral type declared for an enum.
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"

-- | The brace-delimited list of member declarations that make up an enum.
newtype EnumBody =
  EnumBody {
    unEnumBody :: [EnumMemberDeclaration]}
  deriving (Eq, Ord, Read, Show)

_EnumBody = Core.Name "hydra.csharp.syntax.EnumBody"

-- | An enum type declaration, with its modifiers, name, underlying type, and members.
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"

-- | A single named enum member, with optional attributes and an explicit constant value.
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"

-- | An access modifier (new, public, protected, internal, or private) on an enum declaration.
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"

-- | A reference to an enum type by its type name.
newtype EnumType =
  EnumType {
    unEnumType :: TypeName}
  deriving (Eq, Ord, Read, Show)

_EnumType = Core.Name "hydra.csharp.syntax.EnumType"

-- | A simple relational expression or a binary equality/inequality expression.
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"

-- | The equality (==) or inequality (!=) operator.
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"

-- | The add and remove accessor declarations of an event with an explicit accessor body.
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"

-- | An event member declaration, in either its field-like or explicit-accessor form.
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"

-- | A modifier keyword on an event declaration, such as static, virtual, or override.
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"

-- | The exception type and optional identifier caught by a specific catch clause.
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"

-- | A simple AND expression or a binary bitwise exclusive-OR (^) expression.
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"

-- | An explicitly typed parameter of an anonymous function, with an optional modifier.
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"

-- | A local variable declaration whose type is written out explicitly.
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"

-- | An identifier and optional initializer within an explicitly typed local declaration.
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"

-- | A non-assignment expression or an assignment expression.
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"

-- | A non-empty, comma-separated list of expressions, as used in an array creation expression.
newtype ExpressionList =
  ExpressionList {
    unExpressionList :: [Expression]}
  deriving (Eq, Ord, Read, Show)

_ExpressionList = Core.Name "hydra.csharp.syntax.ExpressionList"

-- | An 'extern alias' directive introducing an alias for an external assembly reference.
newtype ExternAliasDirective =
  ExternAliasDirective {
    unExternAliasDirective :: Identifier}
  deriving (Eq, Ord, Read, Show)

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

-- | A field member declaration, with its modifiers, type, and one or more variable declarators.
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"

-- | A modifier keyword on a field declaration, such as static, readonly, or volatile.
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"

-- | The body of a finalizer: a block, expression body, or empty (extern) 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"

-- | A finalizer (destructor) declaration, with its extern/unsafe flags, name, and body.
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"

-- | A single by-value or by-reference formal parameter, with optional attributes and a default value.
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"

-- | A single declarator in a fixed statement, binding a pointer to a variable or expression.
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"

-- | An unsafe fixed-size buffer field declaration inside a struct.
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"

-- | The name and constant size of a single fixed-size buffer member.
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"

-- | An access or unsafe modifier on a fixed-size buffer declaration.
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"

-- | An unsafe 'fixed' statement that pins one or more variables for pointer access.
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"

-- | The float or double floating-point numeric type.
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"

-- | The initializer clause of a for statement: a local variable declaration or expression list.
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"

-- | A C-style for loop, with optional initializer, condition, iterator, and a body statement.
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"

-- | A foreach iteration statement over an enumerable expression, binding each element to a variable.
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"

-- | The fixed parameters of a member, plus an optional trailing params array parameter.
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"

-- | The initial or additional 'from' clause of a query expression, introducing a range variable.
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"

-- | An assembly- or module-level attribute section appearing at the top of a compilation unit.
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"

-- | A goto statement targeting a label, a switch case, or the switch default section.
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"

-- | The 'group ... by ...' clause that ends a query expression, producing grouped results.
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"

-- | A C# identifier: a name for a variable, type, member, or other program element.
newtype Identifier =
  Identifier {
    unIdentifier :: String}
  deriving (Eq, Ord, Read, Show)

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

-- | A simple namespace-or-type name consisting of an identifier and optional type arguments.
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"

-- | An if statement with a boolean condition, a then-branch, and an else-branch.
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"

-- | A local variable declaration using 'var' with inferred type, plain or 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"

-- | The identifier and initializer expression of a 'var'-typed local variable.
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"

-- | A simple exclusive-OR expression or a binary bitwise inclusive-OR (|) expression.
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"

-- | The body of a standard indexer: block accessors or a single expression body.
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"

-- | An indexer member declaration, in its standard or ref-returning form.
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"

-- | An indexer's declared type, optional explicit interface, and formal parameter list.
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"

-- | A modifier keyword on an indexer declaration, such as virtual, override, or abstract.
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"

-- | The left-hand side of a member initializer: an identifier or an indexer argument list.
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"

-- | The right-hand side of a member initializer: an expression or a nested collection initializer.
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"

-- | An integer literal, expressed in decimal, hexadecimal, or binary notation.
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"

-- | One of the built-in integral numeric types (sbyte through char).
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"

-- | The get and/or set accessor attribute lists declared by an interface property or indexer.
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"

-- | An interface type declaration, with its modifiers, type parameters, base interfaces, and members.
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"

-- | An event member declared within an interface body.
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"

-- | An indexer member declared within an interface body.
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"

-- | Any member that can appear in an interface body: method, property, event, or indexer.
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"

-- | A method member declared within an interface body.
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"

-- | The name, parameters, type parameters, and constraints of an interface method declaration.
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"

-- | An access or unsafe modifier on an interface declaration.
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"

-- | A property member declared within an interface body.
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"

-- | A reference to an interface type by its type name.
newtype InterfaceType =
  InterfaceType {
    unInterfaceType :: TypeName}
  deriving (Eq, Ord, Read, Show)

_InterfaceType = Core.Name "hydra.csharp.syntax.InterfaceType"

-- | An interpolated string literal delimited by ordinary double quotes.
newtype InterpolatedRegularStringExpression =
  InterpolatedRegularStringExpression {
    unInterpolatedRegularStringExpression :: String}
  deriving (Eq, Ord, Read, Show)

_InterpolatedRegularStringExpression = Core.Name "hydra.csharp.syntax.InterpolatedRegularStringExpression"

-- | An interpolated string expression, in its regular or verbatim quoting form.
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"

-- | An interpolated string literal using verbatim, at-sign-prefixed quoting.
newtype InterpolatedVerbatimStringExpression =
  InterpolatedVerbatimStringExpression {
    unInterpolatedVerbatimStringExpression :: String}
  deriving (Eq, Ord, Read, Show)

_InterpolatedVerbatimStringExpression = Core.Name "hydra.csharp.syntax.InterpolatedVerbatimStringExpression"

-- | A method or delegate invocation: a primary expression applied to an argument list.
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"

-- | An 'is' pattern-matching expression testing a relational expression against a pattern.
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"

-- | An 'is' type-testing expression checking whether an expression is of a given type.
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"

-- | A while, do, for, or foreach loop statement.
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"

-- | A 'join' clause in a query expression, correlating two sequences on matching keys.
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"

-- | A break, continue, goto, return, or throw statement that transfers control.
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"

-- | A reserved C# keyword.
newtype Keyword =
  Keyword {
    unKeyword :: String}
  deriving (Eq, Ord, Read, Show)

_Keyword = Core.Name "hydra.csharp.syntax.Keyword"

-- | A statement prefixed with a label, usable as the target of a goto statement.
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"

-- | A lambda expression, with its async flag, parameter signature, and body.
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"

-- | A 'let' clause in a query expression that introduces a computed range variable.
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"

-- | A literal value: boolean, integer, real, character, string, or null.
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"

-- | A 'const' local declaration with its type and one or more constant declarators.
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"

-- | The body of a local function: a block, null-conditional invocation, or expression.
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"

-- | A local function declaration, in its standard or ref-returning form.
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"

-- | The name, type parameters, formal parameters, and constraints of a local function.
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"

-- | A modifier on a local function declaration: a ref modifier, or 'async'.
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"

-- | A local variable declaration, in its implicitly typed, explicitly typed, or ref form.
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"

-- | The initializer of a local variable: an expression or an array 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"

-- | The declared type of a local variable, or 'var' for implicit typing.
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"

-- | A 'lock' statement that acquires a mutual-exclusion lock for the duration of its body.
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"

-- | A 'primary.identifier' member access, with optional explicit type arguments.
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"

-- | The left-hand target of a member access: a primary expression, predefined type, or alias.
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"

-- | A single member of an anonymous object initializer, naming or computing a member value.
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"

-- | A non-empty, comma-separated list of member declarators in an anonymous object creation.
newtype MemberDeclaratorList =
  MemberDeclaratorList {
    unMemberDeclaratorList :: [MemberDeclarator]}
  deriving (Eq, Ord, Read, Show)

_MemberDeclaratorList = Core.Name "hydra.csharp.syntax.MemberDeclaratorList"

-- | A 'target = value' pair within an object initializer.
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"

-- | A member's declared name, with an optional explicit interface type qualifier.
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"

-- | The body of a standard method: a block, null-conditional invocation, expression, or empty.
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"

-- | A method member declaration, in its standard or ref-returning form.
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"

-- | The name, type parameters, formal parameters, and constraints of a method declaration.
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"

-- | A modifier on a method declaration: a ref modifier, or 'async'.
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"

-- | The full modifier list of a method declaration, including whether it is 'partial'.
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"

-- | A simple unary expression or a binary multiplication/division/remainder 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"

-- | The multiplication, division, or modulo operator.
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"

-- | An argument of the form 'name: value' passed to an attribute constructor.
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"

-- | A non-empty, comma-separated list of named arguments passed to an attribute.
newtype NamedArgumentList =
  NamedArgumentList {
    unNamedArgumentList :: [NamedArgument]}
  deriving (Eq, Ord, Read, Show)

_NamedArgumentList = Core.Name "hydra.csharp.syntax.NamedArgumentList"

-- | The target expression of a 'nameof' operator, with its chain of accessed parts.
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"

-- | A single '.identifier<TypeArgs>' segment chained within a named entity.
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"

-- | The initial target of a named entity: a simple name, this, base, or a predefined/aliased type.
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"

-- | The extern aliases, using directives, and member declarations within a namespace.
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"

-- | A namespace declaration, naming the namespace and giving its body.
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"

-- | A member of a namespace: a nested namespace declaration or a type declaration.
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"

-- | A reference to a namespace, expressed as a namespace-or-type name.
newtype NamespaceName =
  NamespaceName {
    unNamespaceName :: NamespaceOrTypeName}
  deriving (Eq, Ord, Read, Show)

_NamespaceName = Core.Name "hydra.csharp.syntax.NamespaceName"

-- | A name that may refer to either a namespace or a type: identifier, qualified, or alias-qualified.
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"

-- | A type that is not itself an array type: value, class, interface, delegate, dynamic, or pointer.
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"

-- | Array creation giving the element type, dimension expressions, and rank specifiers directly.
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"

-- | An expression other than an assignment: declaration, conditional, lambda, or query expression.
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"

-- | A simple, binary (??), or throw-expression form of the null-coalescing operator.
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"

-- | A null-conditional element access (?[...]) with its chain of dependent accesses.
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"

-- | A null-conditional invocation (?.method(...) or ?[...]) with optional 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"

-- | The member- or element-access head of a null-conditional invocation expression.
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"

-- | A null-conditional member access (?.member) with its chain of dependent accesses.
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"

-- | A null-conditional member projection used inside an anonymous object initializer.
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"

-- | A numeric type: integral, floating-point, or decimal.
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"

-- | A 'new' expression that constructs an object, with optional arguments and initializer.
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"

-- | An object initializer's member list, or a collection initializer's element list.
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"

-- | The body of an operator overload declaration: a block, expression body, or empty (extern) body.
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"

-- | A user-defined operator overload declaration, with its modifiers, declarator, and body.
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"

-- | The declarator of an operator overload: unary, binary, or conversion form.
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"

-- | A modifier keyword on an operator declaration: public, static, extern, or unsafe.
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"

-- | A single ordering key expression, with an optional ascending/descending direction, in an orderby clause.
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"

-- | The ascending or descending direction of an ordering key in an orderby clause.
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"

-- | A binary operator symbol that may be overloaded via a user-defined operator declaration.
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"

-- | A unary operator symbol that may be overloaded via a user-defined operator declaration.
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"

-- | A trailing 'params' array parameter of a formal parameter list.
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"

-- | The ref, out, or in passing-mode modifier on a fixed parameter.
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"

-- | A modifier on a fixed parameter: a passing-mode modifier, or 'this' for extension methods.
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"

-- | A pattern used in pattern matching: a declaration, constant, or var pattern.
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"

-- | An unsafe pointer indexing expression (pointer[index]).
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"

-- | An unsafe pointer member access expression (pointer->member).
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"

-- | An unsafe pointer type, formed from a pointee value type and a pointer depth.
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"

-- | A single positional (or optionally named) argument in an attribute's argument list.
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"

-- | A non-empty, comma-separated list of positional arguments passed to an attribute.
newtype PositionalArgumentList =
  PositionalArgumentList {
    unPositionalArgumentList :: [PositionalArgument]}
  deriving (Eq, Ord, Read, Show)

_PositionalArgumentList = Core.Name "hydra.csharp.syntax.PositionalArgumentList"

-- | One of the built-in predefined type keywords, such as int, string, or bool.
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"

-- | The primary type-parameter constraint: a class type, or the class/struct/unmanaged constraint.
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"

-- | An expression without an array creation, or an array creation expression.
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"

-- | A primary expression other than array creation: literal, invocation, access, and so on.
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"

-- | The body of a standard property: block accessors or a single expression body.
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"

-- | A property member declaration, in its standard or ref-returning form.
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"

-- | A modifier keyword on a property declaration, such as virtual, override, or abstract.
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"

-- | An 'alias::member' reference, with optional type arguments, using an extern or global alias.
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"

-- | A non-empty, dot-separated sequence of identifiers, as used in a namespace declaration.
newtype QualifiedIdentifier =
  QualifiedIdentifier {
    unQualifiedIdentifier :: [Identifier]}
  deriving (Eq, Ord, Read, Show)

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

-- | A namespace-or-type name qualified with a preceding namespace-or-type and identifier.
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"

-- | The clauses, select/group clause, and optional continuation of a query expression.
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"

-- | A clause in a query expression body: from, let, where, join, or orderby.
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"

-- | An 'into' continuation that feeds a query's results into a further query body.
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"

-- | A LINQ query expression, starting with a from clause and continuing with a query body.
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"

-- | The rank (number of dimensions) of an array type or array creation expression.
newtype RankSpecifier =
  RankSpecifier {
    unRankSpecifier :: Int}
  deriving (Eq, Ord, Read, Show)

_RankSpecifier = Core.Name "hydra.csharp.syntax.RankSpecifier"

-- | Array creation using a rank specifier together with an array initializer, with inferred element type.
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"

-- | The body of a ref-returning get accessor: a block, ref expression, or empty (abstract) 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"

-- | A ref-returning conditional expression, selecting between two variable references.
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"

-- | A ref-returning property or indexer get accessor declaration.
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"

-- | The body of a ref-returning indexer: a ref get accessor, or a single ref 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"

-- | A ref-returning indexer member declaration.
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"

-- | Whether a ref-returning member returns by plain ref or by ref readonly.
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"

-- | The body of a ref-returning local function: a block, or a single ref 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"

-- | A ref-returning local function declaration.
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"

-- | A modifier on a ref-returning local function declaration: static or unsafe.
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"

-- | A local variable declaration that binds a variable by reference.
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"

-- | The identifier and referenced variable in a single ref local variable declarator.
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"

-- | The body of a ref-returning method: a block, ref expression, or empty (extern) body.
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"

-- | A modifier keyword on a ref-returning method declaration.
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"

-- | The body of a ref-returning property: a ref get accessor, or a single ref expression.
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"

-- | A ref-returning method declaration, including its ref kind, header, and 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"

-- | A ref-returning property declaration, including its ref kind and 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"

-- | An implicitly typed local variable declared by reference using 'ref var'.
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"

-- | A reference type: class, interface, array, delegate, or the dynamic type.
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"

-- | A single '{expression[,width][:format]}' hole within a regular interpolated string.
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"

-- | A simple, binary, is-type, is-pattern, or as-type relational expression.
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"

-- | A relational comparison operator: less than, greater than, or their or-equal variants.
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"

-- | The resource acquired by a using statement: a local variable declaration or an expression.
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"

-- | A return statement, in its value-less, value-returning, or ref-returning form.
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"

-- | The declared return type of a member: a ref-qualified type, or void.
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"

-- | A secondary type-parameter constraint: an interface type or another type parameter.
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"

-- | A non-empty list of secondary constraints on a type parameter.
newtype SecondaryConstraints =
  SecondaryConstraints {
    unSecondaryConstraints :: [SecondaryConstraint]}
  deriving (Eq, Ord, Read, Show)

_SecondaryConstraints = Core.Name "hydra.csharp.syntax.SecondaryConstraints"

-- | The final clause of a query body: a 'select' projection or a 'group by' clause.
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"

-- | An if or switch statement.
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"

-- | A simple additive expression or a binary left/right-shift expression.
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"

-- | The left-shift (<<) or right-shift (>>) operator.
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"

-- | The ordinary ternary conditional expression: 'condition ? true : false'.
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"

-- | A simple identifier reference, with an optional list of explicit type arguments.
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"

-- | A numeric type or the bool type.
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"

-- | A catch clause naming an exception type and/or filter, with a handler block.
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"

-- | A 'stackalloc' expression that allocates a block of memory on the stack.
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"

-- | A field-like event declaration, with its type and one or more declarators.
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"

-- | A standard (non-ref-returning) indexer declaration.
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"

-- | A standard (non-ref-returning) local function declaration.
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"

-- | A standard (non-ref-returning) method declaration.
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"

-- | A standard (non-ref-returning) property declaration.
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"

-- | A labeled statement, a declaration statement, or an embedded statement.
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"

-- | An expression usable as a statement on its own, such as an invocation or assignment.
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"

-- | A non-empty, comma-separated list of statement expressions, as used in a for statement.
newtype StatementExpressionList =
  StatementExpressionList {
    unStatementExpressionList :: [StatementExpression]}
  deriving (Eq, Ord, Read, Show)

_StatementExpressionList = Core.Name "hydra.csharp.syntax.StatementExpressionList"

-- | The body of a static constructor: a block, expression body, or empty (extern) body.
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"

-- | A static constructor declaration for a type.
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"

-- | The extern and unsafe flags of a static constructor declaration.
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"

-- | A struct type declaration, with its modifiers, type parameters, interfaces, and body.
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"

-- | Any member that can appear in a struct body, including fixed-size buffer declarations.
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"

-- | A modifier keyword on a struct declaration, such as readonly or unsafe.
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"

-- | A struct type or an enum type, as used in the definition of value types.
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"

-- | A reference to a struct type: a named type, a simple type, or a tuple type.
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"

-- | A pattern and optional guard expression used in a pattern-matching switch section.
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"

-- | A single label of a switch section: a pattern branch, or the default label.
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"

-- | A group of switch labels sharing a common statement list within a switch statement.
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"

-- | A switch statement, dispatching on an expression across its switch sections.
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"

-- | A try statement with its protected block, catch clauses, and optional finally block.
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"

-- | A single element of a tuple expression, with an optional name.
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"

-- | A tuple literal expression, either a list of named elements or a deconstruction tuple.
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"

-- | A tuple type formed from a non-empty list of named or unnamed element types.
newtype TupleType =
  TupleType {
    unTupleType :: [TupleTypeElement]}
  deriving (Eq, Ord, Read, Show)

_TupleType = Core.Name "hydra.csharp.syntax.TupleType"

-- | A single element type of a tuple type, with an optional element name.
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"

-- | A C# type: a reference type, value type, type parameter, or pointer type.
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"

-- | A list of type arguments supplied to a generic type or method.
newtype TypeArgumentList =
  TypeArgumentList {
    unTypeArgumentList :: [Type]}
  deriving (Eq, Ord, Read, Show)

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

-- | A top-level or nested type declaration: class, struct, interface, enum, or delegate.
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"

-- | A name that is known to refer to a type, expressed as a namespace-or-type name.
newtype TypeName =
  TypeName {
    unTypeName :: NamespaceOrTypeName}
  deriving (Eq, Ord, Read, Show)

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

-- | A single generic type parameter, identified by its name.
newtype TypeParameter =
  TypeParameter {
    unTypeParameter :: Identifier}
  deriving (Eq, Ord, Read, Show)

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

-- | The primary, secondary, and constructor constraints on a single type parameter.
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"

-- | A 'where T : ...' clause constraining one type parameter of a generic declaration.
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"

-- | A non-empty, comma-separated list of type parameters in a generic declaration.
newtype TypeParameterList =
  TypeParameterList {
    unTypeParameterList :: [TypeParameterPart]}
  deriving (Eq, Ord, Read, Show)

_TypeParameterList = Core.Name "hydra.csharp.syntax.TypeParameterList"

-- | A single type parameter within a type parameter list, with its optional attributes.
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"

-- | A 'typeof' expression yielding the System.Type of a type, unbound generic type, or void.
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"

-- | A unary expression: a primary expression, or a prefixed unary/cast/await operation.
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"

-- | The declarator for a user-defined unary operator overload, naming its single parameter.
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"

-- | An unbound generic type name, as used in a typeof expression (e.g. Dictionary<,>).
newtype UnboundTypeName =
  UnboundTypeName {
    unUnboundTypeName :: [UnboundTypeNamePart]}
  deriving (Eq, Ord, Read, Show)

_UnboundTypeName = Core.Name "hydra.csharp.syntax.UnboundTypeName"

-- | A single segment of an unbound type name, with its aliasing flag and generic dimension.
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"

-- | A type usable with the unsafe 'sizeof' operator: a value type or pointer type.
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"

-- | A 'using alias = namespace-or-type;' directive introducing a using alias.
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"

-- | A using directive: an alias directive, a namespace import, or a using-static directive.
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"

-- | A 'using' statement that deterministically disposes an acquired resource after its 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"

-- | A struct or enum type, in its non-nullable or nullable ('?') form.
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"

-- | An identifier and optional initializer within a field or local variable declaration.
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"

-- | A non-empty, comma-separated list of variable declarators, as used in an event declaration.
newtype VariableDeclarators =
  VariableDeclarators {
    unVariableDeclarators :: [VariableDeclarator]}
  deriving (Eq, Ord, Read, Show)

_VariableDeclarators = Core.Name "hydra.csharp.syntax.VariableDeclarators"

-- | The initializer of a variable: an expression or a nested array initializer.
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"

-- | A reference to a variable, expressed as an expression.
newtype VariableReference =
  VariableReference {
    unVariableReference :: Expression}
  deriving (Eq, Ord, Read, Show)

_VariableReference = Core.Name "hydra.csharp.syntax.VariableReference"

-- | The in (contravariant) or out (covariant) variance annotation on a generic type 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"

-- | A single type parameter of an interface or delegate, with optional variance annotation.
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"

-- | The list of variant type parameters declared by a generic interface or delegate.
newtype VariantTypeParameters =
  VariantTypeParameters {
    unVariantTypeParameters :: [VariantTypeParameter]}
  deriving (Eq, Ord, Read, Show)

_VariantTypeParameters = Core.Name "hydra.csharp.syntax.VariantTypeParameters"

-- | A single '{expression[,width][:format]}' hole within a verbatim interpolated string.
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"

-- | A while iteration statement that tests its condition before each execution of the body.
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"

-- | A 'yield return' or 'yield break' statement used within an iterator.
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"