hydra-ext-0.18.0: src/main/haskell/Hydra/Ext/Dsl/Csharp/Syntax.hs

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

-- | DSL functions for hydra.ext.csharp.syntax

module Hydra.Ext.Dsl.Csharp.Syntax where

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

-- | DSL name token for hydra.ext.csharp.syntax.AccessorBody
accessorBodyAccessorBody :: Typed.TypedName Syntax.AccessorBody
accessorBodyAccessorBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AccessorBody")

-- | DSL injection for the block variant of hydra.ext.csharp.syntax.AccessorBody
accessorBodyBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.AccessorBody
accessorBodyBlock x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "block"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the empty variant of hydra.ext.csharp.syntax.AccessorBody
accessorBodyEmpty :: Typed.TypedTerm Syntax.AccessorBody
accessorBodyEmpty =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "empty"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.AccessorBody
accessorBodyExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.AccessorBody
accessorBodyExpression x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "expression"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.csharp.syntax.AccessorDeclaration
accessorDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm (Maybe Syntax.AccessorModifier) -> Typed.TypedTerm Syntax.AccessorBody -> Typed.TypedTerm Syntax.AccessorDeclaration
accessorDeclaration attributes modifier body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "modifier"),
          Model.fieldTerm = (Typed.unTypedTerm modifier)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.AccessorDeclaration
accessorDeclarationAccessorDeclaration :: Typed.TypedName Syntax.AccessorDeclaration
accessorDeclarationAccessorDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AccessorDeclaration")

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.AccessorDeclaration
accessorDeclarationAttributes :: Typed.TypedTerm Syntax.AccessorDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes)
accessorDeclarationAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorDeclaration"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.AccessorDeclaration
accessorDeclarationBody :: Typed.TypedTerm Syntax.AccessorDeclaration -> Typed.TypedTerm Syntax.AccessorBody
accessorDeclarationBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorDeclaration"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the modifier field of hydra.ext.csharp.syntax.AccessorDeclaration
accessorDeclarationModifier :: Typed.TypedTerm Syntax.AccessorDeclaration -> Typed.TypedTerm (Maybe Syntax.AccessorModifier)
accessorDeclarationModifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorDeclaration"),
        Model.projectionFieldName = (Model.Name "modifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.AccessorDeclaration
accessorDeclarationWithAttributes :: Typed.TypedTerm Syntax.AccessorDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.AccessorDeclaration
accessorDeclarationWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "modifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorDeclaration"),
              Model.projectionFieldName = (Model.Name "modifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the body field of hydra.ext.csharp.syntax.AccessorDeclaration
accessorDeclarationWithBody :: Typed.TypedTerm Syntax.AccessorDeclaration -> Typed.TypedTerm Syntax.AccessorBody -> Typed.TypedTerm Syntax.AccessorDeclaration
accessorDeclarationWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorDeclaration"),
              Model.projectionFieldName = (Model.Name "modifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the modifier field of hydra.ext.csharp.syntax.AccessorDeclaration
accessorDeclarationWithModifier :: Typed.TypedTerm Syntax.AccessorDeclaration -> Typed.TypedTerm (Maybe Syntax.AccessorModifier) -> Typed.TypedTerm Syntax.AccessorDeclaration
accessorDeclarationWithModifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL name token for hydra.ext.csharp.syntax.AccessorDeclarations
accessorDeclarationsAccessorDeclarations :: Typed.TypedName Syntax.AccessorDeclarations
accessorDeclarationsAccessorDeclarations = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AccessorDeclarations")

-- | DSL injection for the get variant of hydra.ext.csharp.syntax.AccessorDeclarations
accessorDeclarationsGet :: Typed.TypedTerm (Maybe Syntax.AccessorDeclaration) -> Typed.TypedTerm Syntax.AccessorDeclarations
accessorDeclarationsGet x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorDeclarations"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "get"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the set variant of hydra.ext.csharp.syntax.AccessorDeclarations
accessorDeclarationsSet :: Typed.TypedTerm (Maybe Syntax.AccessorDeclaration) -> Typed.TypedTerm Syntax.AccessorDeclarations
accessorDeclarationsSet x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorDeclarations"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "set"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.AccessorModifier
accessorModifierAccessorModifier :: Typed.TypedName Syntax.AccessorModifier
accessorModifierAccessorModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AccessorModifier")

-- | DSL injection for the internal variant of hydra.ext.csharp.syntax.AccessorModifier
accessorModifierInternal :: Typed.TypedTerm Syntax.AccessorModifier
accessorModifierInternal =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "internal"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the internalProtected variant of hydra.ext.csharp.syntax.AccessorModifier
accessorModifierInternalProtected :: Typed.TypedTerm Syntax.AccessorModifier
accessorModifierInternalProtected =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "internalProtected"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the private variant of hydra.ext.csharp.syntax.AccessorModifier
accessorModifierPrivate :: Typed.TypedTerm Syntax.AccessorModifier
accessorModifierPrivate =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "private"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the privateProtected variant of hydra.ext.csharp.syntax.AccessorModifier
accessorModifierPrivateProtected :: Typed.TypedTerm Syntax.AccessorModifier
accessorModifierPrivateProtected =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "privateProtected"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the protected variant of hydra.ext.csharp.syntax.AccessorModifier
accessorModifierProtected :: Typed.TypedTerm Syntax.AccessorModifier
accessorModifierProtected =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "protected"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the protectedInternal variant of hydra.ext.csharp.syntax.AccessorModifier
accessorModifierProtectedInternal :: Typed.TypedTerm Syntax.AccessorModifier
accessorModifierProtectedInternal =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "protectedInternal"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the protectedPrivate variant of hydra.ext.csharp.syntax.AccessorModifier
accessorModifierProtectedPrivate :: Typed.TypedTerm Syntax.AccessorModifier
accessorModifierProtectedPrivate =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "protectedPrivate"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL constructor for hydra.ext.csharp.syntax.AccessorsEventDeclaration
accessorsEventDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.EventModifier] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.MemberName -> Typed.TypedTerm Syntax.EventAccessorDeclarations -> Typed.TypedTerm Syntax.AccessorsEventDeclaration
accessorsEventDeclaration attributes modifiers type_ name accessors =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm modifiers)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "accessors"),
          Model.fieldTerm = (Typed.unTypedTerm accessors)}]}))

-- | DSL accessor for the accessors field of hydra.ext.csharp.syntax.AccessorsEventDeclaration
accessorsEventDeclarationAccessors :: Typed.TypedTerm Syntax.AccessorsEventDeclaration -> Typed.TypedTerm Syntax.EventAccessorDeclarations
accessorsEventDeclarationAccessors x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"),
        Model.projectionFieldName = (Model.Name "accessors")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.AccessorsEventDeclaration
accessorsEventDeclarationAccessorsEventDeclaration :: Typed.TypedName Syntax.AccessorsEventDeclaration
accessorsEventDeclarationAccessorsEventDeclaration =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration")

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.AccessorsEventDeclaration
accessorsEventDeclarationAttributes :: Typed.TypedTerm Syntax.AccessorsEventDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes)
accessorsEventDeclarationAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.AccessorsEventDeclaration
accessorsEventDeclarationModifiers :: Typed.TypedTerm Syntax.AccessorsEventDeclaration -> Typed.TypedTerm [Syntax.EventModifier]
accessorsEventDeclarationModifiers x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"),
        Model.projectionFieldName = (Model.Name "modifiers")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the name field of hydra.ext.csharp.syntax.AccessorsEventDeclaration
accessorsEventDeclarationName :: Typed.TypedTerm Syntax.AccessorsEventDeclaration -> Typed.TypedTerm Syntax.MemberName
accessorsEventDeclarationName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.AccessorsEventDeclaration
accessorsEventDeclarationType :: Typed.TypedTerm Syntax.AccessorsEventDeclaration -> Typed.TypedTerm Syntax.Type
accessorsEventDeclarationType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the accessors field of hydra.ext.csharp.syntax.AccessorsEventDeclaration
accessorsEventDeclarationWithAccessors :: Typed.TypedTerm Syntax.AccessorsEventDeclaration -> Typed.TypedTerm Syntax.EventAccessorDeclarations -> Typed.TypedTerm Syntax.AccessorsEventDeclaration
accessorsEventDeclarationWithAccessors original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "accessors"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.AccessorsEventDeclaration
accessorsEventDeclarationWithAttributes :: Typed.TypedTerm Syntax.AccessorsEventDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.AccessorsEventDeclaration
accessorsEventDeclarationWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "accessors"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"),
              Model.projectionFieldName = (Model.Name "accessors")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.AccessorsEventDeclaration
accessorsEventDeclarationWithModifiers :: Typed.TypedTerm Syntax.AccessorsEventDeclaration -> Typed.TypedTerm [Syntax.EventModifier] -> Typed.TypedTerm Syntax.AccessorsEventDeclaration
accessorsEventDeclarationWithModifiers original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "accessors"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"),
              Model.projectionFieldName = (Model.Name "accessors")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.csharp.syntax.AccessorsEventDeclaration
accessorsEventDeclarationWithName :: Typed.TypedTerm Syntax.AccessorsEventDeclaration -> Typed.TypedTerm Syntax.MemberName -> Typed.TypedTerm Syntax.AccessorsEventDeclaration
accessorsEventDeclarationWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "accessors"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"),
              Model.projectionFieldName = (Model.Name "accessors")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.AccessorsEventDeclaration
accessorsEventDeclarationWithType :: Typed.TypedTerm Syntax.AccessorsEventDeclaration -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.AccessorsEventDeclaration
accessorsEventDeclarationWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "accessors"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AccessorsEventDeclaration"),
              Model.projectionFieldName = (Model.Name "accessors")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.AddRemoveAccessorDeclaration
addRemoveAccessorDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.AddRemoveAccessorDeclaration
addRemoveAccessorDeclaration attributes body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AddRemoveAccessorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.AddRemoveAccessorDeclaration
addRemoveAccessorDeclarationAddRemoveAccessorDeclaration :: Typed.TypedName Syntax.AddRemoveAccessorDeclaration
addRemoveAccessorDeclarationAddRemoveAccessorDeclaration =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AddRemoveAccessorDeclaration")

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.AddRemoveAccessorDeclaration
addRemoveAccessorDeclarationAttributes :: Typed.TypedTerm Syntax.AddRemoveAccessorDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes)
addRemoveAccessorDeclarationAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AddRemoveAccessorDeclaration"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.AddRemoveAccessorDeclaration
addRemoveAccessorDeclarationBody :: Typed.TypedTerm Syntax.AddRemoveAccessorDeclaration -> Typed.TypedTerm Syntax.Block
addRemoveAccessorDeclarationBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AddRemoveAccessorDeclaration"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.AddRemoveAccessorDeclaration
addRemoveAccessorDeclarationWithAttributes :: Typed.TypedTerm Syntax.AddRemoveAccessorDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.AddRemoveAccessorDeclaration
addRemoveAccessorDeclarationWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AddRemoveAccessorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AddRemoveAccessorDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the body field of hydra.ext.csharp.syntax.AddRemoveAccessorDeclaration
addRemoveAccessorDeclarationWithBody :: Typed.TypedTerm Syntax.AddRemoveAccessorDeclaration -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.AddRemoveAccessorDeclaration
addRemoveAccessorDeclarationWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AddRemoveAccessorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AddRemoveAccessorDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.AdditiveExpression
additiveExpressionAdditiveExpression :: Typed.TypedName Syntax.AdditiveExpression
additiveExpressionAdditiveExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AdditiveExpression")

-- | DSL injection for the binary variant of hydra.ext.csharp.syntax.AdditiveExpression
additiveExpressionBinary :: Typed.TypedTerm Syntax.BinaryAdditiveExpression -> Typed.TypedTerm Syntax.AdditiveExpression
additiveExpressionBinary x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AdditiveExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "binary"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the simple variant of hydra.ext.csharp.syntax.AdditiveExpression
additiveExpressionSimple :: Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.AdditiveExpression
additiveExpressionSimple x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AdditiveExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "simple"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.AdditiveOperator
additiveOperatorAdditiveOperator :: Typed.TypedName Syntax.AdditiveOperator
additiveOperatorAdditiveOperator = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AdditiveOperator")

-- | DSL injection for the minus variant of hydra.ext.csharp.syntax.AdditiveOperator
additiveOperatorMinus :: Typed.TypedTerm Syntax.AdditiveOperator
additiveOperatorMinus =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AdditiveOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "minus"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the plus variant of hydra.ext.csharp.syntax.AdditiveOperator
additiveOperatorPlus :: Typed.TypedTerm Syntax.AdditiveOperator
additiveOperatorPlus =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AdditiveOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "plus"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.csharp.syntax.AndExpression
andExpressionAndExpression :: Typed.TypedName Syntax.AndExpression
andExpressionAndExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AndExpression")

-- | DSL injection for the binary variant of hydra.ext.csharp.syntax.AndExpression
andExpressionBinary :: Typed.TypedTerm Syntax.BinaryAndExpression -> Typed.TypedTerm Syntax.AndExpression
andExpressionBinary x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AndExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "binary"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the simple variant of hydra.ext.csharp.syntax.AndExpression
andExpressionSimple :: Typed.TypedTerm Syntax.EqualityExpression -> Typed.TypedTerm Syntax.AndExpression
andExpressionSimple x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AndExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "simple"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.AnonymousFunctionBody
anonymousFunctionBodyAnonymousFunctionBody :: Typed.TypedName Syntax.AnonymousFunctionBody
anonymousFunctionBodyAnonymousFunctionBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AnonymousFunctionBody")

-- | DSL injection for the block variant of hydra.ext.csharp.syntax.AnonymousFunctionBody
anonymousFunctionBodyBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.AnonymousFunctionBody
anonymousFunctionBodyBlock x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousFunctionBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "block"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.AnonymousFunctionBody
anonymousFunctionBodyExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.AnonymousFunctionBody
anonymousFunctionBodyExpression x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousFunctionBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "expression"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the nullConditionalInvocation variant of hydra.ext.csharp.syntax.AnonymousFunctionBody
anonymousFunctionBodyNullConditionalInvocation :: Typed.TypedTerm Syntax.NullConditionalInvocationExpression -> Typed.TypedTerm Syntax.AnonymousFunctionBody
anonymousFunctionBodyNullConditionalInvocation x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousFunctionBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "nullConditionalInvocation"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.AnonymousFunctionBody
anonymousFunctionBodyRef :: Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.AnonymousFunctionBody
anonymousFunctionBodyRef x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousFunctionBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "ref"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.AnonymousFunctionParameterModifier
anonymousFunctionParameterModifierAnonymousFunctionParameterModifier :: Typed.TypedName Syntax.AnonymousFunctionParameterModifier
anonymousFunctionParameterModifierAnonymousFunctionParameterModifier =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AnonymousFunctionParameterModifier")

-- | DSL injection for the in variant of hydra.ext.csharp.syntax.AnonymousFunctionParameterModifier
anonymousFunctionParameterModifierIn :: Typed.TypedTerm Syntax.AnonymousFunctionParameterModifier
anonymousFunctionParameterModifierIn =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousFunctionParameterModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "in"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the out variant of hydra.ext.csharp.syntax.AnonymousFunctionParameterModifier
anonymousFunctionParameterModifierOut :: Typed.TypedTerm Syntax.AnonymousFunctionParameterModifier
anonymousFunctionParameterModifierOut =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousFunctionParameterModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "out"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.AnonymousFunctionParameterModifier
anonymousFunctionParameterModifierRef :: Typed.TypedTerm Syntax.AnonymousFunctionParameterModifier
anonymousFunctionParameterModifierRef =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousFunctionParameterModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "ref"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.csharp.syntax.AnonymousFunctionSignature
anonymousFunctionSignatureAnonymousFunctionSignature :: Typed.TypedName Syntax.AnonymousFunctionSignature
anonymousFunctionSignatureAnonymousFunctionSignature =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AnonymousFunctionSignature")

-- | DSL injection for the explicit variant of hydra.ext.csharp.syntax.AnonymousFunctionSignature
anonymousFunctionSignatureExplicit :: Typed.TypedTerm [Syntax.ExplicitAnonymousFunctionParameter] -> Typed.TypedTerm Syntax.AnonymousFunctionSignature
anonymousFunctionSignatureExplicit x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousFunctionSignature"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "explicit"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the implicit variant of hydra.ext.csharp.syntax.AnonymousFunctionSignature
anonymousFunctionSignatureImplicit :: Typed.TypedTerm [Syntax.Identifier] -> Typed.TypedTerm Syntax.AnonymousFunctionSignature
anonymousFunctionSignatureImplicit x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousFunctionSignature"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "implicit"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.csharp.syntax.AnonymousMethodExpression
anonymousMethodExpression :: Typed.TypedTerm Bool -> Typed.TypedTerm [Syntax.ExplicitAnonymousFunctionParameter] -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.AnonymousMethodExpression
anonymousMethodExpression async signature body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousMethodExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "async"),
          Model.fieldTerm = (Typed.unTypedTerm async)},
        Model.Field {
          Model.fieldName = (Model.Name "signature"),
          Model.fieldTerm = (Typed.unTypedTerm signature)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.AnonymousMethodExpression
anonymousMethodExpressionAnonymousMethodExpression :: Typed.TypedName Syntax.AnonymousMethodExpression
anonymousMethodExpressionAnonymousMethodExpression =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AnonymousMethodExpression")

-- | DSL accessor for the async field of hydra.ext.csharp.syntax.AnonymousMethodExpression
anonymousMethodExpressionAsync :: Typed.TypedTerm Syntax.AnonymousMethodExpression -> Typed.TypedTerm Bool
anonymousMethodExpressionAsync x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousMethodExpression"),
        Model.projectionFieldName = (Model.Name "async")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.AnonymousMethodExpression
anonymousMethodExpressionBody :: Typed.TypedTerm Syntax.AnonymousMethodExpression -> Typed.TypedTerm Syntax.Block
anonymousMethodExpressionBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousMethodExpression"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the signature field of hydra.ext.csharp.syntax.AnonymousMethodExpression
anonymousMethodExpressionSignature :: Typed.TypedTerm Syntax.AnonymousMethodExpression -> Typed.TypedTerm [Syntax.ExplicitAnonymousFunctionParameter]
anonymousMethodExpressionSignature x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousMethodExpression"),
        Model.projectionFieldName = (Model.Name "signature")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the async field of hydra.ext.csharp.syntax.AnonymousMethodExpression
anonymousMethodExpressionWithAsync :: Typed.TypedTerm Syntax.AnonymousMethodExpression -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.AnonymousMethodExpression
anonymousMethodExpressionWithAsync original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousMethodExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "async"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "signature"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousMethodExpression"),
              Model.projectionFieldName = (Model.Name "signature")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousMethodExpression"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the body field of hydra.ext.csharp.syntax.AnonymousMethodExpression
anonymousMethodExpressionWithBody :: Typed.TypedTerm Syntax.AnonymousMethodExpression -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.AnonymousMethodExpression
anonymousMethodExpressionWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousMethodExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "async"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousMethodExpression"),
              Model.projectionFieldName = (Model.Name "async")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "signature"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousMethodExpression"),
              Model.projectionFieldName = (Model.Name "signature")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the signature field of hydra.ext.csharp.syntax.AnonymousMethodExpression
anonymousMethodExpressionWithSignature :: Typed.TypedTerm Syntax.AnonymousMethodExpression -> Typed.TypedTerm [Syntax.ExplicitAnonymousFunctionParameter] -> Typed.TypedTerm Syntax.AnonymousMethodExpression
anonymousMethodExpressionWithSignature original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousMethodExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "async"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousMethodExpression"),
              Model.projectionFieldName = (Model.Name "async")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "signature"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AnonymousMethodExpression"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.Argument
argument :: Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.ArgumentValue -> Typed.TypedTerm Syntax.Argument
argument name value =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.Argument"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Typed.unTypedTerm value)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.Argument
argumentArgument :: Typed.TypedName Syntax.Argument
argumentArgument = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.Argument")

-- | DSL constructor for the hydra.ext.csharp.syntax.ArgumentList wrapper
argumentList :: Typed.TypedTerm [Syntax.Argument] -> Typed.TypedTerm Syntax.ArgumentList
argumentList x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.ArgumentList"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.ArgumentList
argumentListArgumentList :: Typed.TypedName Syntax.ArgumentList
argumentListArgumentList = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ArgumentList")

-- | DSL accessor for the name field of hydra.ext.csharp.syntax.Argument
argumentName :: Typed.TypedTerm Syntax.Argument -> Typed.TypedTerm (Maybe Syntax.Identifier)
argumentName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Argument"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the value field of hydra.ext.csharp.syntax.Argument
argumentValue :: Typed.TypedTerm Syntax.Argument -> Typed.TypedTerm Syntax.ArgumentValue
argumentValue x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Argument"),
        Model.projectionFieldName = (Model.Name "value")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.ArgumentValue
argumentValueArgumentValue :: Typed.TypedName Syntax.ArgumentValue
argumentValueArgumentValue = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ArgumentValue")

-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.ArgumentValue
argumentValueExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ArgumentValue
argumentValueExpression x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ArgumentValue"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "expression"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the in variant of hydra.ext.csharp.syntax.ArgumentValue
argumentValueIn :: Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.ArgumentValue
argumentValueIn x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ArgumentValue"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "in"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the out variant of hydra.ext.csharp.syntax.ArgumentValue
argumentValueOut :: Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.ArgumentValue
argumentValueOut x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ArgumentValue"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "out"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.ArgumentValue
argumentValueRef :: Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.ArgumentValue
argumentValueRef x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ArgumentValue"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "ref"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL updater for the name field of hydra.ext.csharp.syntax.Argument
argumentWithName :: Typed.TypedTerm Syntax.Argument -> Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.Argument
argumentWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.Argument"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Argument"),
              Model.projectionFieldName = (Model.Name "value")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the value field of hydra.ext.csharp.syntax.Argument
argumentWithValue :: Typed.TypedTerm Syntax.Argument -> Typed.TypedTerm Syntax.ArgumentValue -> Typed.TypedTerm Syntax.Argument
argumentWithValue original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.Argument"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Argument"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.ArrayCreationExpression
arrayCreationExpressionArrayCreationExpression :: Typed.TypedName Syntax.ArrayCreationExpression
arrayCreationExpressionArrayCreationExpression =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ArrayCreationExpression")

-- | DSL injection for the arrayType variant of hydra.ext.csharp.syntax.ArrayCreationExpression
arrayCreationExpressionArrayType :: Typed.TypedTerm Syntax.ArrayTypeArrayCreationExpression -> Typed.TypedTerm Syntax.ArrayCreationExpression
arrayCreationExpressionArrayType x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayCreationExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "arrayType"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the nonArrayType variant of hydra.ext.csharp.syntax.ArrayCreationExpression
arrayCreationExpressionNonArrayType :: Typed.TypedTerm Syntax.NonArrayTypeArrayCreationExpression -> Typed.TypedTerm Syntax.ArrayCreationExpression
arrayCreationExpressionNonArrayType x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayCreationExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "nonArrayType"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the rankSpecifier variant of hydra.ext.csharp.syntax.ArrayCreationExpression
arrayCreationExpressionRankSpecifier :: Typed.TypedTerm Syntax.RankSpecifierArrayCreationExpression -> Typed.TypedTerm Syntax.ArrayCreationExpression
arrayCreationExpressionRankSpecifier x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayCreationExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "rankSpecifier"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for the hydra.ext.csharp.syntax.ArrayInitializer wrapper
arrayInitializer :: Typed.TypedTerm [Syntax.VariableInitializer] -> Typed.TypedTerm Syntax.ArrayInitializer
arrayInitializer x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayInitializer"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.ArrayInitializer
arrayInitializerArrayInitializer :: Typed.TypedName Syntax.ArrayInitializer
arrayInitializerArrayInitializer = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ArrayInitializer")

-- | DSL constructor for hydra.ext.csharp.syntax.ArrayType
arrayType :: Typed.TypedTerm Syntax.NonArrayType -> Typed.TypedTerm [Syntax.RankSpecifier] -> Typed.TypedTerm Syntax.ArrayType
arrayType type_ rank =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "rank"),
          Model.fieldTerm = (Typed.unTypedTerm rank)}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.ArrayTypeArrayCreationExpression
arrayTypeArrayCreationExpression :: Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm Syntax.ArrayInitializer -> Typed.TypedTerm Syntax.ArrayTypeArrayCreationExpression
arrayTypeArrayCreationExpression type_ initializer =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayTypeArrayCreationExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Typed.unTypedTerm initializer)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.ArrayTypeArrayCreationExpression
arrayTypeArrayCreationExpressionArrayTypeArrayCreationExpression :: Typed.TypedName Syntax.ArrayTypeArrayCreationExpression
arrayTypeArrayCreationExpressionArrayTypeArrayCreationExpression =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ArrayTypeArrayCreationExpression")

-- | DSL accessor for the initializer field of hydra.ext.csharp.syntax.ArrayTypeArrayCreationExpression
arrayTypeArrayCreationExpressionInitializer :: Typed.TypedTerm Syntax.ArrayTypeArrayCreationExpression -> Typed.TypedTerm Syntax.ArrayInitializer
arrayTypeArrayCreationExpressionInitializer x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayTypeArrayCreationExpression"),
        Model.projectionFieldName = (Model.Name "initializer")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.ArrayTypeArrayCreationExpression
arrayTypeArrayCreationExpressionType :: Typed.TypedTerm Syntax.ArrayTypeArrayCreationExpression -> Typed.TypedTerm Syntax.ArrayType
arrayTypeArrayCreationExpressionType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayTypeArrayCreationExpression"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the initializer field of hydra.ext.csharp.syntax.ArrayTypeArrayCreationExpression
arrayTypeArrayCreationExpressionWithInitializer :: Typed.TypedTerm Syntax.ArrayTypeArrayCreationExpression -> Typed.TypedTerm Syntax.ArrayInitializer -> Typed.TypedTerm Syntax.ArrayTypeArrayCreationExpression
arrayTypeArrayCreationExpressionWithInitializer original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayTypeArrayCreationExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayTypeArrayCreationExpression"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.ArrayTypeArrayCreationExpression
arrayTypeArrayCreationExpressionWithType :: Typed.TypedTerm Syntax.ArrayTypeArrayCreationExpression -> Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm Syntax.ArrayTypeArrayCreationExpression
arrayTypeArrayCreationExpressionWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayTypeArrayCreationExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayTypeArrayCreationExpression"),
              Model.projectionFieldName = (Model.Name "initializer")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL name token for hydra.ext.csharp.syntax.ArrayType
arrayTypeArrayType :: Typed.TypedName Syntax.ArrayType
arrayTypeArrayType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ArrayType")

-- | DSL accessor for the rank field of hydra.ext.csharp.syntax.ArrayType
arrayTypeRank :: Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm [Syntax.RankSpecifier]
arrayTypeRank x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayType"),
        Model.projectionFieldName = (Model.Name "rank")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.ArrayType
arrayTypeType :: Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm Syntax.NonArrayType
arrayTypeType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayType"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the rank field of hydra.ext.csharp.syntax.ArrayType
arrayTypeWithRank :: Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm [Syntax.RankSpecifier] -> Typed.TypedTerm Syntax.ArrayType
arrayTypeWithRank original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayType"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "rank"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.ArrayType
arrayTypeWithType :: Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm Syntax.NonArrayType -> Typed.TypedTerm Syntax.ArrayType
arrayTypeWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "rank"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ArrayType"),
              Model.projectionFieldName = (Model.Name "rank")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.AsTypeExpression
asTypeExpression :: Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.AsTypeExpression
asTypeExpression expression type_ =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AsTypeExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm expression)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.AsTypeExpression
asTypeExpressionAsTypeExpression :: Typed.TypedName Syntax.AsTypeExpression
asTypeExpressionAsTypeExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AsTypeExpression")

-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.AsTypeExpression
asTypeExpressionExpression :: Typed.TypedTerm Syntax.AsTypeExpression -> Typed.TypedTerm Syntax.RelationalExpression
asTypeExpressionExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AsTypeExpression"),
        Model.projectionFieldName = (Model.Name "expression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.AsTypeExpression
asTypeExpressionType :: Typed.TypedTerm Syntax.AsTypeExpression -> Typed.TypedTerm Syntax.Type
asTypeExpressionType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AsTypeExpression"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the expression field of hydra.ext.csharp.syntax.AsTypeExpression
asTypeExpressionWithExpression :: Typed.TypedTerm Syntax.AsTypeExpression -> Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.AsTypeExpression
asTypeExpressionWithExpression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AsTypeExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AsTypeExpression"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.AsTypeExpression
asTypeExpressionWithType :: Typed.TypedTerm Syntax.AsTypeExpression -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.AsTypeExpression
asTypeExpressionWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AsTypeExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AsTypeExpression"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.Assignment
assignment :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.AssignmentOperator -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Assignment
assignment left operator right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.Assignment"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Typed.unTypedTerm operator)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.Assignment
assignmentAssignment :: Typed.TypedName Syntax.Assignment
assignmentAssignment = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.Assignment")

-- | DSL accessor for the left field of hydra.ext.csharp.syntax.Assignment
assignmentLeft :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm Syntax.UnaryExpression
assignmentLeft x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Assignment"),
        Model.projectionFieldName = (Model.Name "left")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL constructor for hydra.ext.csharp.syntax.AssignmentMemberDeclarator
assignmentMemberDeclarator :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.AssignmentMemberDeclarator
assignmentMemberDeclarator identifier expression =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentMemberDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm identifier)},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm expression)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.AssignmentMemberDeclarator
assignmentMemberDeclaratorAssignmentMemberDeclarator :: Typed.TypedName Syntax.AssignmentMemberDeclarator
assignmentMemberDeclaratorAssignmentMemberDeclarator =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AssignmentMemberDeclarator")

-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.AssignmentMemberDeclarator
assignmentMemberDeclaratorExpression :: Typed.TypedTerm Syntax.AssignmentMemberDeclarator -> Typed.TypedTerm Syntax.Expression
assignmentMemberDeclaratorExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentMemberDeclarator"),
        Model.projectionFieldName = (Model.Name "expression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.AssignmentMemberDeclarator
assignmentMemberDeclaratorIdentifier :: Typed.TypedTerm Syntax.AssignmentMemberDeclarator -> Typed.TypedTerm Syntax.Identifier
assignmentMemberDeclaratorIdentifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentMemberDeclarator"),
        Model.projectionFieldName = (Model.Name "identifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the expression field of hydra.ext.csharp.syntax.AssignmentMemberDeclarator
assignmentMemberDeclaratorWithExpression :: Typed.TypedTerm Syntax.AssignmentMemberDeclarator -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.AssignmentMemberDeclarator
assignmentMemberDeclaratorWithExpression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentMemberDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentMemberDeclarator"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.AssignmentMemberDeclarator
assignmentMemberDeclaratorWithIdentifier :: Typed.TypedTerm Syntax.AssignmentMemberDeclarator -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.AssignmentMemberDeclarator
assignmentMemberDeclaratorWithIdentifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentMemberDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentMemberDeclarator"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL accessor for the operator field of hydra.ext.csharp.syntax.Assignment
assignmentOperator :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm Syntax.AssignmentOperator
assignmentOperator x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Assignment"),
        Model.projectionFieldName = (Model.Name "operator")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL injection for the andEquals variant of hydra.ext.csharp.syntax.AssignmentOperator
assignmentOperatorAndEquals :: Typed.TypedTerm Syntax.AssignmentOperator
assignmentOperatorAndEquals =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "andEquals"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.csharp.syntax.AssignmentOperator
assignmentOperatorAssignmentOperator :: Typed.TypedName Syntax.AssignmentOperator
assignmentOperatorAssignmentOperator = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AssignmentOperator")

-- | DSL injection for the divideEquals variant of hydra.ext.csharp.syntax.AssignmentOperator
assignmentOperatorDivideEquals :: Typed.TypedTerm Syntax.AssignmentOperator
assignmentOperatorDivideEquals =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "divideEquals"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the leftShiftEquals variant of hydra.ext.csharp.syntax.AssignmentOperator
assignmentOperatorLeftShiftEquals :: Typed.TypedTerm Syntax.AssignmentOperator
assignmentOperatorLeftShiftEquals =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "leftShiftEquals"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the minusEquals variant of hydra.ext.csharp.syntax.AssignmentOperator
assignmentOperatorMinusEquals :: Typed.TypedTerm Syntax.AssignmentOperator
assignmentOperatorMinusEquals =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "minusEquals"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the modEquals variant of hydra.ext.csharp.syntax.AssignmentOperator
assignmentOperatorModEquals :: Typed.TypedTerm Syntax.AssignmentOperator
assignmentOperatorModEquals =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "modEquals"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the orEquals variant of hydra.ext.csharp.syntax.AssignmentOperator
assignmentOperatorOrEquals :: Typed.TypedTerm Syntax.AssignmentOperator
assignmentOperatorOrEquals =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "orEquals"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the plusEquals variant of hydra.ext.csharp.syntax.AssignmentOperator
assignmentOperatorPlusEquals :: Typed.TypedTerm Syntax.AssignmentOperator
assignmentOperatorPlusEquals =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "plusEquals"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the rightShiftEquals variant of hydra.ext.csharp.syntax.AssignmentOperator
assignmentOperatorRightShiftEquals :: Typed.TypedTerm Syntax.AssignmentOperator
assignmentOperatorRightShiftEquals =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "rightShiftEquals"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the simple variant of hydra.ext.csharp.syntax.AssignmentOperator
assignmentOperatorSimple :: Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.AssignmentOperator
assignmentOperatorSimple x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "simple"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the timesEquals variant of hydra.ext.csharp.syntax.AssignmentOperator
assignmentOperatorTimesEquals :: Typed.TypedTerm Syntax.AssignmentOperator
assignmentOperatorTimesEquals =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "timesEquals"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the xorEquals variant of hydra.ext.csharp.syntax.AssignmentOperator
assignmentOperatorXorEquals :: Typed.TypedTerm Syntax.AssignmentOperator
assignmentOperatorXorEquals =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AssignmentOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "xorEquals"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL accessor for the right field of hydra.ext.csharp.syntax.Assignment
assignmentRight :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm Syntax.Expression
assignmentRight x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Assignment"),
        Model.projectionFieldName = (Model.Name "right")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the left field of hydra.ext.csharp.syntax.Assignment
assignmentWithLeft :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.Assignment
assignmentWithLeft original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.Assignment"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Assignment"),
              Model.projectionFieldName = (Model.Name "operator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Assignment"),
              Model.projectionFieldName = (Model.Name "right")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the operator field of hydra.ext.csharp.syntax.Assignment
assignmentWithOperator :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm Syntax.AssignmentOperator -> Typed.TypedTerm Syntax.Assignment
assignmentWithOperator original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.Assignment"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Assignment"),
              Model.projectionFieldName = (Model.Name "left")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Assignment"),
              Model.projectionFieldName = (Model.Name "right")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the right field of hydra.ext.csharp.syntax.Assignment
assignmentWithRight :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Assignment
assignmentWithRight original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.Assignment"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Assignment"),
              Model.projectionFieldName = (Model.Name "left")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Assignment"),
              Model.projectionFieldName = (Model.Name "operator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.Attribute
attribute :: Typed.TypedTerm Syntax.AttributeName -> Typed.TypedTerm (Maybe Syntax.AttributeArguments) -> Typed.TypedTerm Syntax.Attribute
attribute name arguments =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.Attribute"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Typed.unTypedTerm arguments)}]}))

-- | DSL constructor for the hydra.ext.csharp.syntax.AttributeArgumentExpression wrapper
attributeArgumentExpression :: Typed.TypedTerm Syntax.NonAssignmentExpression -> Typed.TypedTerm Syntax.AttributeArgumentExpression
attributeArgumentExpression x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeArgumentExpression"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.AttributeArgumentExpression
attributeArgumentExpressionAttributeArgumentExpression :: Typed.TypedName Syntax.AttributeArgumentExpression
attributeArgumentExpressionAttributeArgumentExpression =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AttributeArgumentExpression")

-- | DSL accessor for the arguments field of hydra.ext.csharp.syntax.Attribute
attributeArguments :: Typed.TypedTerm Syntax.Attribute -> Typed.TypedTerm (Maybe Syntax.AttributeArguments)
attributeArguments x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Attribute"),
        Model.projectionFieldName = (Model.Name "arguments")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL constructor for hydra.ext.csharp.syntax.AttributeArguments
attributeArguments2 :: Typed.TypedTerm (Maybe Syntax.PositionalArgumentList) -> Typed.TypedTerm (Maybe Syntax.NamedArgumentList) -> Typed.TypedTerm Syntax.AttributeArguments
attributeArguments2 positonal named =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeArguments"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "positonal"),
          Model.fieldTerm = (Typed.unTypedTerm positonal)},
        Model.Field {
          Model.fieldName = (Model.Name "named"),
          Model.fieldTerm = (Typed.unTypedTerm named)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.AttributeArguments
attributeArgumentsAttributeArguments :: Typed.TypedName Syntax.AttributeArguments
attributeArgumentsAttributeArguments = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AttributeArguments")

-- | DSL accessor for the named field of hydra.ext.csharp.syntax.AttributeArguments
attributeArgumentsNamed :: Typed.TypedTerm Syntax.AttributeArguments -> Typed.TypedTerm (Maybe Syntax.NamedArgumentList)
attributeArgumentsNamed x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeArguments"),
        Model.projectionFieldName = (Model.Name "named")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the positonal field of hydra.ext.csharp.syntax.AttributeArguments
attributeArgumentsPositonal :: Typed.TypedTerm Syntax.AttributeArguments -> Typed.TypedTerm (Maybe Syntax.PositionalArgumentList)
attributeArgumentsPositonal x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeArguments"),
        Model.projectionFieldName = (Model.Name "positonal")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the named field of hydra.ext.csharp.syntax.AttributeArguments
attributeArgumentsWithNamed :: Typed.TypedTerm Syntax.AttributeArguments -> Typed.TypedTerm (Maybe Syntax.NamedArgumentList) -> Typed.TypedTerm Syntax.AttributeArguments
attributeArgumentsWithNamed original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeArguments"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "positonal"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeArguments"),
              Model.projectionFieldName = (Model.Name "positonal")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "named"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the positonal field of hydra.ext.csharp.syntax.AttributeArguments
attributeArgumentsWithPositonal :: Typed.TypedTerm Syntax.AttributeArguments -> Typed.TypedTerm (Maybe Syntax.PositionalArgumentList) -> Typed.TypedTerm Syntax.AttributeArguments
attributeArgumentsWithPositonal original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeArguments"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "positonal"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "named"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeArguments"),
              Model.projectionFieldName = (Model.Name "named")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL name token for hydra.ext.csharp.syntax.Attribute
attributeAttribute :: Typed.TypedName Syntax.Attribute
attributeAttribute = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.Attribute")

-- | DSL constructor for the hydra.ext.csharp.syntax.AttributeList wrapper
attributeList :: Typed.TypedTerm [Syntax.Attribute] -> Typed.TypedTerm Syntax.AttributeList
attributeList x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeList"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.AttributeList
attributeListAttributeList :: Typed.TypedName Syntax.AttributeList
attributeListAttributeList = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AttributeList")

-- | DSL accessor for the name field of hydra.ext.csharp.syntax.Attribute
attributeName :: Typed.TypedTerm Syntax.Attribute -> Typed.TypedTerm Syntax.AttributeName
attributeName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Attribute"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL constructor for the hydra.ext.csharp.syntax.AttributeName wrapper
attributeName2 :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.AttributeName
attributeName2 x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeName"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.AttributeName
attributeNameAttributeName :: Typed.TypedName Syntax.AttributeName
attributeNameAttributeName = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AttributeName")

-- | DSL constructor for hydra.ext.csharp.syntax.AttributeSection
attributeSection :: Typed.TypedTerm (Maybe Syntax.AttributeTarget) -> Typed.TypedTerm Syntax.AttributeList -> Typed.TypedTerm Syntax.AttributeSection
attributeSection target attributes =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeSection"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "target"),
          Model.fieldTerm = (Typed.unTypedTerm target)},
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.AttributeSection
attributeSectionAttributeSection :: Typed.TypedName Syntax.AttributeSection
attributeSectionAttributeSection = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AttributeSection")

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.AttributeSection
attributeSectionAttributes :: Typed.TypedTerm Syntax.AttributeSection -> Typed.TypedTerm Syntax.AttributeList
attributeSectionAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeSection"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the target field of hydra.ext.csharp.syntax.AttributeSection
attributeSectionTarget :: Typed.TypedTerm Syntax.AttributeSection -> Typed.TypedTerm (Maybe Syntax.AttributeTarget)
attributeSectionTarget x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeSection"),
        Model.projectionFieldName = (Model.Name "target")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.AttributeSection
attributeSectionWithAttributes :: Typed.TypedTerm Syntax.AttributeSection -> Typed.TypedTerm Syntax.AttributeList -> Typed.TypedTerm Syntax.AttributeSection
attributeSectionWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeSection"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "target"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeSection"),
              Model.projectionFieldName = (Model.Name "target")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the target field of hydra.ext.csharp.syntax.AttributeSection
attributeSectionWithTarget :: Typed.TypedTerm Syntax.AttributeSection -> Typed.TypedTerm (Maybe Syntax.AttributeTarget) -> Typed.TypedTerm Syntax.AttributeSection
attributeSectionWithTarget original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeSection"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "target"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeSection"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL name token for hydra.ext.csharp.syntax.AttributeTarget
attributeTargetAttributeTarget :: Typed.TypedName Syntax.AttributeTarget
attributeTargetAttributeTarget = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.AttributeTarget")

-- | DSL injection for the identifier variant of hydra.ext.csharp.syntax.AttributeTarget
attributeTargetIdentifier :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.AttributeTarget
attributeTargetIdentifier x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeTarget"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "identifier"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the keyword variant of hydra.ext.csharp.syntax.AttributeTarget
attributeTargetKeyword :: Typed.TypedTerm Syntax.Keyword -> Typed.TypedTerm Syntax.AttributeTarget
attributeTargetKeyword x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.AttributeTarget"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "keyword"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL updater for the arguments field of hydra.ext.csharp.syntax.Attribute
attributeWithArguments :: Typed.TypedTerm Syntax.Attribute -> Typed.TypedTerm (Maybe Syntax.AttributeArguments) -> Typed.TypedTerm Syntax.Attribute
attributeWithArguments original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.Attribute"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Attribute"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the name field of hydra.ext.csharp.syntax.Attribute
attributeWithName :: Typed.TypedTerm Syntax.Attribute -> Typed.TypedTerm Syntax.AttributeName -> Typed.TypedTerm Syntax.Attribute
attributeWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.Attribute"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Attribute"),
              Model.projectionFieldName = (Model.Name "arguments")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for the hydra.ext.csharp.syntax.Attributes wrapper
attributes :: Typed.TypedTerm [Syntax.AttributeSection] -> Typed.TypedTerm Syntax.Attributes
attributes x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.Attributes"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.Attributes
attributesAttributes :: Typed.TypedName Syntax.Attributes
attributesAttributes = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.Attributes")

-- | DSL injection for the arguments variant of hydra.ext.csharp.syntax.BaseAccess
baseAccessArguments :: Typed.TypedTerm Syntax.ArgumentList -> Typed.TypedTerm Syntax.BaseAccess
baseAccessArguments x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BaseAccess"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "arguments"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.BaseAccess
baseAccessBaseAccess :: Typed.TypedName Syntax.BaseAccess
baseAccessBaseAccess = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BaseAccess")

-- | DSL injection for the identifier variant of hydra.ext.csharp.syntax.BaseAccess
baseAccessIdentifier :: Typed.TypedTerm Syntax.BaseAccessWithIdentifier -> Typed.TypedTerm Syntax.BaseAccess
baseAccessIdentifier x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BaseAccess"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "identifier"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.csharp.syntax.BaseAccessWithIdentifier
baseAccessWithIdentifier :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.BaseAccessWithIdentifier
baseAccessWithIdentifier identifier typeArguments =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BaseAccessWithIdentifier"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm identifier)},
        Model.Field {
          Model.fieldName = (Model.Name "typeArguments"),
          Model.fieldTerm = (Typed.unTypedTerm typeArguments)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.BaseAccessWithIdentifier
baseAccessWithIdentifierBaseAccessWithIdentifier :: Typed.TypedName Syntax.BaseAccessWithIdentifier
baseAccessWithIdentifierBaseAccessWithIdentifier =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BaseAccessWithIdentifier")

-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.BaseAccessWithIdentifier
baseAccessWithIdentifierIdentifier :: Typed.TypedTerm Syntax.BaseAccessWithIdentifier -> Typed.TypedTerm Syntax.Identifier
baseAccessWithIdentifierIdentifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BaseAccessWithIdentifier"),
        Model.projectionFieldName = (Model.Name "identifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the typeArguments field of hydra.ext.csharp.syntax.BaseAccessWithIdentifier
baseAccessWithIdentifierTypeArguments :: Typed.TypedTerm Syntax.BaseAccessWithIdentifier -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList)
baseAccessWithIdentifierTypeArguments x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BaseAccessWithIdentifier"),
        Model.projectionFieldName = (Model.Name "typeArguments")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.BaseAccessWithIdentifier
baseAccessWithIdentifierWithIdentifier :: Typed.TypedTerm Syntax.BaseAccessWithIdentifier -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.BaseAccessWithIdentifier
baseAccessWithIdentifierWithIdentifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BaseAccessWithIdentifier"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "typeArguments"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BaseAccessWithIdentifier"),
              Model.projectionFieldName = (Model.Name "typeArguments")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the typeArguments field of hydra.ext.csharp.syntax.BaseAccessWithIdentifier
baseAccessWithIdentifierWithTypeArguments :: Typed.TypedTerm Syntax.BaseAccessWithIdentifier -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.BaseAccessWithIdentifier
baseAccessWithIdentifierWithTypeArguments original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BaseAccessWithIdentifier"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BaseAccessWithIdentifier"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeArguments"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.BinaryAdditiveExpression
binaryAdditiveExpression :: Typed.TypedTerm Syntax.AdditiveExpression -> Typed.TypedTerm Syntax.AdditiveOperator -> Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.BinaryAdditiveExpression
binaryAdditiveExpression left operator right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAdditiveExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Typed.unTypedTerm operator)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.BinaryAdditiveExpression
binaryAdditiveExpressionBinaryAdditiveExpression :: Typed.TypedName Syntax.BinaryAdditiveExpression
binaryAdditiveExpressionBinaryAdditiveExpression =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BinaryAdditiveExpression")

-- | DSL accessor for the left field of hydra.ext.csharp.syntax.BinaryAdditiveExpression
binaryAdditiveExpressionLeft :: Typed.TypedTerm Syntax.BinaryAdditiveExpression -> Typed.TypedTerm Syntax.AdditiveExpression
binaryAdditiveExpressionLeft x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAdditiveExpression"),
        Model.projectionFieldName = (Model.Name "left")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the operator field of hydra.ext.csharp.syntax.BinaryAdditiveExpression
binaryAdditiveExpressionOperator :: Typed.TypedTerm Syntax.BinaryAdditiveExpression -> Typed.TypedTerm Syntax.AdditiveOperator
binaryAdditiveExpressionOperator x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAdditiveExpression"),
        Model.projectionFieldName = (Model.Name "operator")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the right field of hydra.ext.csharp.syntax.BinaryAdditiveExpression
binaryAdditiveExpressionRight :: Typed.TypedTerm Syntax.BinaryAdditiveExpression -> Typed.TypedTerm Syntax.MultiplicativeExpression
binaryAdditiveExpressionRight x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAdditiveExpression"),
        Model.projectionFieldName = (Model.Name "right")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the left field of hydra.ext.csharp.syntax.BinaryAdditiveExpression
binaryAdditiveExpressionWithLeft :: Typed.TypedTerm Syntax.BinaryAdditiveExpression -> Typed.TypedTerm Syntax.AdditiveExpression -> Typed.TypedTerm Syntax.BinaryAdditiveExpression
binaryAdditiveExpressionWithLeft original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAdditiveExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAdditiveExpression"),
              Model.projectionFieldName = (Model.Name "operator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAdditiveExpression"),
              Model.projectionFieldName = (Model.Name "right")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the operator field of hydra.ext.csharp.syntax.BinaryAdditiveExpression
binaryAdditiveExpressionWithOperator :: Typed.TypedTerm Syntax.BinaryAdditiveExpression -> Typed.TypedTerm Syntax.AdditiveOperator -> Typed.TypedTerm Syntax.BinaryAdditiveExpression
binaryAdditiveExpressionWithOperator original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAdditiveExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAdditiveExpression"),
              Model.projectionFieldName = (Model.Name "left")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAdditiveExpression"),
              Model.projectionFieldName = (Model.Name "right")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the right field of hydra.ext.csharp.syntax.BinaryAdditiveExpression
binaryAdditiveExpressionWithRight :: Typed.TypedTerm Syntax.BinaryAdditiveExpression -> Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.BinaryAdditiveExpression
binaryAdditiveExpressionWithRight original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAdditiveExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAdditiveExpression"),
              Model.projectionFieldName = (Model.Name "left")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAdditiveExpression"),
              Model.projectionFieldName = (Model.Name "operator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.BinaryAndExpression
binaryAndExpression :: Typed.TypedTerm Syntax.AndExpression -> Typed.TypedTerm Syntax.EqualityExpression -> Typed.TypedTerm Syntax.BinaryAndExpression
binaryAndExpression left right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAndExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.BinaryAndExpression
binaryAndExpressionBinaryAndExpression :: Typed.TypedName Syntax.BinaryAndExpression
binaryAndExpressionBinaryAndExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BinaryAndExpression")

-- | DSL accessor for the left field of hydra.ext.csharp.syntax.BinaryAndExpression
binaryAndExpressionLeft :: Typed.TypedTerm Syntax.BinaryAndExpression -> Typed.TypedTerm Syntax.AndExpression
binaryAndExpressionLeft x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAndExpression"),
        Model.projectionFieldName = (Model.Name "left")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the right field of hydra.ext.csharp.syntax.BinaryAndExpression
binaryAndExpressionRight :: Typed.TypedTerm Syntax.BinaryAndExpression -> Typed.TypedTerm Syntax.EqualityExpression
binaryAndExpressionRight x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAndExpression"),
        Model.projectionFieldName = (Model.Name "right")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the left field of hydra.ext.csharp.syntax.BinaryAndExpression
binaryAndExpressionWithLeft :: Typed.TypedTerm Syntax.BinaryAndExpression -> Typed.TypedTerm Syntax.AndExpression -> Typed.TypedTerm Syntax.BinaryAndExpression
binaryAndExpressionWithLeft original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAndExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAndExpression"),
              Model.projectionFieldName = (Model.Name "right")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the right field of hydra.ext.csharp.syntax.BinaryAndExpression
binaryAndExpressionWithRight :: Typed.TypedTerm Syntax.BinaryAndExpression -> Typed.TypedTerm Syntax.EqualityExpression -> Typed.TypedTerm Syntax.BinaryAndExpression
binaryAndExpressionWithRight original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAndExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryAndExpression"),
              Model.projectionFieldName = (Model.Name "left")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.BinaryConditionalAndExpression
binaryConditionalAndExpression :: Typed.TypedTerm Syntax.ConditionalAndExpression -> Typed.TypedTerm Syntax.InclusiveOrExpression -> Typed.TypedTerm Syntax.BinaryConditionalAndExpression
binaryConditionalAndExpression left right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalAndExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.BinaryConditionalAndExpression
binaryConditionalAndExpressionBinaryConditionalAndExpression :: Typed.TypedName Syntax.BinaryConditionalAndExpression
binaryConditionalAndExpressionBinaryConditionalAndExpression =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalAndExpression")

-- | DSL accessor for the left field of hydra.ext.csharp.syntax.BinaryConditionalAndExpression
binaryConditionalAndExpressionLeft :: Typed.TypedTerm Syntax.BinaryConditionalAndExpression -> Typed.TypedTerm Syntax.ConditionalAndExpression
binaryConditionalAndExpressionLeft x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalAndExpression"),
        Model.projectionFieldName = (Model.Name "left")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the right field of hydra.ext.csharp.syntax.BinaryConditionalAndExpression
binaryConditionalAndExpressionRight :: Typed.TypedTerm Syntax.BinaryConditionalAndExpression -> Typed.TypedTerm Syntax.InclusiveOrExpression
binaryConditionalAndExpressionRight x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalAndExpression"),
        Model.projectionFieldName = (Model.Name "right")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the left field of hydra.ext.csharp.syntax.BinaryConditionalAndExpression
binaryConditionalAndExpressionWithLeft :: Typed.TypedTerm Syntax.BinaryConditionalAndExpression -> Typed.TypedTerm Syntax.ConditionalAndExpression -> Typed.TypedTerm Syntax.BinaryConditionalAndExpression
binaryConditionalAndExpressionWithLeft original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalAndExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalAndExpression"),
              Model.projectionFieldName = (Model.Name "right")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the right field of hydra.ext.csharp.syntax.BinaryConditionalAndExpression
binaryConditionalAndExpressionWithRight :: Typed.TypedTerm Syntax.BinaryConditionalAndExpression -> Typed.TypedTerm Syntax.InclusiveOrExpression -> Typed.TypedTerm Syntax.BinaryConditionalAndExpression
binaryConditionalAndExpressionWithRight original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalAndExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalAndExpression"),
              Model.projectionFieldName = (Model.Name "left")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.BinaryConditionalOrExpression
binaryConditionalOrExpression :: Typed.TypedTerm Syntax.ConditionalOrExpression -> Typed.TypedTerm Syntax.ConditionalAndExpression -> Typed.TypedTerm Syntax.BinaryConditionalOrExpression
binaryConditionalOrExpression left right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalOrExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.BinaryConditionalOrExpression
binaryConditionalOrExpressionBinaryConditionalOrExpression :: Typed.TypedName Syntax.BinaryConditionalOrExpression
binaryConditionalOrExpressionBinaryConditionalOrExpression =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalOrExpression")

-- | DSL accessor for the left field of hydra.ext.csharp.syntax.BinaryConditionalOrExpression
binaryConditionalOrExpressionLeft :: Typed.TypedTerm Syntax.BinaryConditionalOrExpression -> Typed.TypedTerm Syntax.ConditionalOrExpression
binaryConditionalOrExpressionLeft x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalOrExpression"),
        Model.projectionFieldName = (Model.Name "left")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the right field of hydra.ext.csharp.syntax.BinaryConditionalOrExpression
binaryConditionalOrExpressionRight :: Typed.TypedTerm Syntax.BinaryConditionalOrExpression -> Typed.TypedTerm Syntax.ConditionalAndExpression
binaryConditionalOrExpressionRight x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalOrExpression"),
        Model.projectionFieldName = (Model.Name "right")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the left field of hydra.ext.csharp.syntax.BinaryConditionalOrExpression
binaryConditionalOrExpressionWithLeft :: Typed.TypedTerm Syntax.BinaryConditionalOrExpression -> Typed.TypedTerm Syntax.ConditionalOrExpression -> Typed.TypedTerm Syntax.BinaryConditionalOrExpression
binaryConditionalOrExpressionWithLeft original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalOrExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalOrExpression"),
              Model.projectionFieldName = (Model.Name "right")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the right field of hydra.ext.csharp.syntax.BinaryConditionalOrExpression
binaryConditionalOrExpressionWithRight :: Typed.TypedTerm Syntax.BinaryConditionalOrExpression -> Typed.TypedTerm Syntax.ConditionalAndExpression -> Typed.TypedTerm Syntax.BinaryConditionalOrExpression
binaryConditionalOrExpressionWithRight original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalOrExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryConditionalOrExpression"),
              Model.projectionFieldName = (Model.Name "left")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.BinaryEqualityExpression
binaryEqualityExpression :: Typed.TypedTerm Syntax.EqualityExpression -> Typed.TypedTerm Syntax.EqualityOperator -> Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.BinaryEqualityExpression
binaryEqualityExpression left operator right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryEqualityExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Typed.unTypedTerm operator)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.BinaryEqualityExpression
binaryEqualityExpressionBinaryEqualityExpression :: Typed.TypedName Syntax.BinaryEqualityExpression
binaryEqualityExpressionBinaryEqualityExpression =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BinaryEqualityExpression")

-- | DSL accessor for the left field of hydra.ext.csharp.syntax.BinaryEqualityExpression
binaryEqualityExpressionLeft :: Typed.TypedTerm Syntax.BinaryEqualityExpression -> Typed.TypedTerm Syntax.EqualityExpression
binaryEqualityExpressionLeft x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryEqualityExpression"),
        Model.projectionFieldName = (Model.Name "left")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the operator field of hydra.ext.csharp.syntax.BinaryEqualityExpression
binaryEqualityExpressionOperator :: Typed.TypedTerm Syntax.BinaryEqualityExpression -> Typed.TypedTerm Syntax.EqualityOperator
binaryEqualityExpressionOperator x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryEqualityExpression"),
        Model.projectionFieldName = (Model.Name "operator")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the right field of hydra.ext.csharp.syntax.BinaryEqualityExpression
binaryEqualityExpressionRight :: Typed.TypedTerm Syntax.BinaryEqualityExpression -> Typed.TypedTerm Syntax.RelationalExpression
binaryEqualityExpressionRight x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryEqualityExpression"),
        Model.projectionFieldName = (Model.Name "right")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the left field of hydra.ext.csharp.syntax.BinaryEqualityExpression
binaryEqualityExpressionWithLeft :: Typed.TypedTerm Syntax.BinaryEqualityExpression -> Typed.TypedTerm Syntax.EqualityExpression -> Typed.TypedTerm Syntax.BinaryEqualityExpression
binaryEqualityExpressionWithLeft original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryEqualityExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryEqualityExpression"),
              Model.projectionFieldName = (Model.Name "operator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryEqualityExpression"),
              Model.projectionFieldName = (Model.Name "right")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the operator field of hydra.ext.csharp.syntax.BinaryEqualityExpression
binaryEqualityExpressionWithOperator :: Typed.TypedTerm Syntax.BinaryEqualityExpression -> Typed.TypedTerm Syntax.EqualityOperator -> Typed.TypedTerm Syntax.BinaryEqualityExpression
binaryEqualityExpressionWithOperator original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryEqualityExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryEqualityExpression"),
              Model.projectionFieldName = (Model.Name "left")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryEqualityExpression"),
              Model.projectionFieldName = (Model.Name "right")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the right field of hydra.ext.csharp.syntax.BinaryEqualityExpression
binaryEqualityExpressionWithRight :: Typed.TypedTerm Syntax.BinaryEqualityExpression -> Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.BinaryEqualityExpression
binaryEqualityExpressionWithRight original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryEqualityExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryEqualityExpression"),
              Model.projectionFieldName = (Model.Name "left")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryEqualityExpression"),
              Model.projectionFieldName = (Model.Name "operator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.BinaryExclusiveOrExpression
binaryExclusiveOrExpression :: Typed.TypedTerm Syntax.ExclusiveOrExpression -> Typed.TypedTerm Syntax.AndExpression -> Typed.TypedTerm Syntax.BinaryExclusiveOrExpression
binaryExclusiveOrExpression left right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryExclusiveOrExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.BinaryExclusiveOrExpression
binaryExclusiveOrExpressionBinaryExclusiveOrExpression :: Typed.TypedName Syntax.BinaryExclusiveOrExpression
binaryExclusiveOrExpressionBinaryExclusiveOrExpression =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BinaryExclusiveOrExpression")

-- | DSL accessor for the left field of hydra.ext.csharp.syntax.BinaryExclusiveOrExpression
binaryExclusiveOrExpressionLeft :: Typed.TypedTerm Syntax.BinaryExclusiveOrExpression -> Typed.TypedTerm Syntax.ExclusiveOrExpression
binaryExclusiveOrExpressionLeft x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryExclusiveOrExpression"),
        Model.projectionFieldName = (Model.Name "left")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the right field of hydra.ext.csharp.syntax.BinaryExclusiveOrExpression
binaryExclusiveOrExpressionRight :: Typed.TypedTerm Syntax.BinaryExclusiveOrExpression -> Typed.TypedTerm Syntax.AndExpression
binaryExclusiveOrExpressionRight x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryExclusiveOrExpression"),
        Model.projectionFieldName = (Model.Name "right")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the left field of hydra.ext.csharp.syntax.BinaryExclusiveOrExpression
binaryExclusiveOrExpressionWithLeft :: Typed.TypedTerm Syntax.BinaryExclusiveOrExpression -> Typed.TypedTerm Syntax.ExclusiveOrExpression -> Typed.TypedTerm Syntax.BinaryExclusiveOrExpression
binaryExclusiveOrExpressionWithLeft original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryExclusiveOrExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryExclusiveOrExpression"),
              Model.projectionFieldName = (Model.Name "right")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the right field of hydra.ext.csharp.syntax.BinaryExclusiveOrExpression
binaryExclusiveOrExpressionWithRight :: Typed.TypedTerm Syntax.BinaryExclusiveOrExpression -> Typed.TypedTerm Syntax.AndExpression -> Typed.TypedTerm Syntax.BinaryExclusiveOrExpression
binaryExclusiveOrExpressionWithRight original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryExclusiveOrExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryExclusiveOrExpression"),
              Model.projectionFieldName = (Model.Name "left")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.BinaryInclusiveOrExpression
binaryInclusiveOrExpression :: Typed.TypedTerm Syntax.InclusiveOrExpression -> Typed.TypedTerm Syntax.ExclusiveOrExpression -> Typed.TypedTerm Syntax.BinaryInclusiveOrExpression
binaryInclusiveOrExpression left right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryInclusiveOrExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.BinaryInclusiveOrExpression
binaryInclusiveOrExpressionBinaryInclusiveOrExpression :: Typed.TypedName Syntax.BinaryInclusiveOrExpression
binaryInclusiveOrExpressionBinaryInclusiveOrExpression =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BinaryInclusiveOrExpression")

-- | DSL accessor for the left field of hydra.ext.csharp.syntax.BinaryInclusiveOrExpression
binaryInclusiveOrExpressionLeft :: Typed.TypedTerm Syntax.BinaryInclusiveOrExpression -> Typed.TypedTerm Syntax.InclusiveOrExpression
binaryInclusiveOrExpressionLeft x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryInclusiveOrExpression"),
        Model.projectionFieldName = (Model.Name "left")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the right field of hydra.ext.csharp.syntax.BinaryInclusiveOrExpression
binaryInclusiveOrExpressionRight :: Typed.TypedTerm Syntax.BinaryInclusiveOrExpression -> Typed.TypedTerm Syntax.ExclusiveOrExpression
binaryInclusiveOrExpressionRight x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryInclusiveOrExpression"),
        Model.projectionFieldName = (Model.Name "right")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the left field of hydra.ext.csharp.syntax.BinaryInclusiveOrExpression
binaryInclusiveOrExpressionWithLeft :: Typed.TypedTerm Syntax.BinaryInclusiveOrExpression -> Typed.TypedTerm Syntax.InclusiveOrExpression -> Typed.TypedTerm Syntax.BinaryInclusiveOrExpression
binaryInclusiveOrExpressionWithLeft original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryInclusiveOrExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryInclusiveOrExpression"),
              Model.projectionFieldName = (Model.Name "right")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the right field of hydra.ext.csharp.syntax.BinaryInclusiveOrExpression
binaryInclusiveOrExpressionWithRight :: Typed.TypedTerm Syntax.BinaryInclusiveOrExpression -> Typed.TypedTerm Syntax.ExclusiveOrExpression -> Typed.TypedTerm Syntax.BinaryInclusiveOrExpression
binaryInclusiveOrExpressionWithRight original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryInclusiveOrExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryInclusiveOrExpression"),
              Model.projectionFieldName = (Model.Name "left")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.BinaryMultiplicativeExpression
binaryMultiplicativeExpression :: Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.MultiplicativeOperator -> Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.BinaryMultiplicativeExpression
binaryMultiplicativeExpression left operator right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryMultiplicativeExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Typed.unTypedTerm operator)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.BinaryMultiplicativeExpression
binaryMultiplicativeExpressionBinaryMultiplicativeExpression :: Typed.TypedName Syntax.BinaryMultiplicativeExpression
binaryMultiplicativeExpressionBinaryMultiplicativeExpression =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BinaryMultiplicativeExpression")

-- | DSL accessor for the left field of hydra.ext.csharp.syntax.BinaryMultiplicativeExpression
binaryMultiplicativeExpressionLeft :: Typed.TypedTerm Syntax.BinaryMultiplicativeExpression -> Typed.TypedTerm Syntax.MultiplicativeExpression
binaryMultiplicativeExpressionLeft x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryMultiplicativeExpression"),
        Model.projectionFieldName = (Model.Name "left")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the operator field of hydra.ext.csharp.syntax.BinaryMultiplicativeExpression
binaryMultiplicativeExpressionOperator :: Typed.TypedTerm Syntax.BinaryMultiplicativeExpression -> Typed.TypedTerm Syntax.MultiplicativeOperator
binaryMultiplicativeExpressionOperator x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryMultiplicativeExpression"),
        Model.projectionFieldName = (Model.Name "operator")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the right field of hydra.ext.csharp.syntax.BinaryMultiplicativeExpression
binaryMultiplicativeExpressionRight :: Typed.TypedTerm Syntax.BinaryMultiplicativeExpression -> Typed.TypedTerm Syntax.UnaryExpression
binaryMultiplicativeExpressionRight x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryMultiplicativeExpression"),
        Model.projectionFieldName = (Model.Name "right")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the left field of hydra.ext.csharp.syntax.BinaryMultiplicativeExpression
binaryMultiplicativeExpressionWithLeft :: Typed.TypedTerm Syntax.BinaryMultiplicativeExpression -> Typed.TypedTerm Syntax.MultiplicativeExpression -> Typed.TypedTerm Syntax.BinaryMultiplicativeExpression
binaryMultiplicativeExpressionWithLeft original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryMultiplicativeExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryMultiplicativeExpression"),
              Model.projectionFieldName = (Model.Name "operator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryMultiplicativeExpression"),
              Model.projectionFieldName = (Model.Name "right")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the operator field of hydra.ext.csharp.syntax.BinaryMultiplicativeExpression
binaryMultiplicativeExpressionWithOperator :: Typed.TypedTerm Syntax.BinaryMultiplicativeExpression -> Typed.TypedTerm Syntax.MultiplicativeOperator -> Typed.TypedTerm Syntax.BinaryMultiplicativeExpression
binaryMultiplicativeExpressionWithOperator original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryMultiplicativeExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryMultiplicativeExpression"),
              Model.projectionFieldName = (Model.Name "left")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryMultiplicativeExpression"),
              Model.projectionFieldName = (Model.Name "right")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the right field of hydra.ext.csharp.syntax.BinaryMultiplicativeExpression
binaryMultiplicativeExpressionWithRight :: Typed.TypedTerm Syntax.BinaryMultiplicativeExpression -> Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.BinaryMultiplicativeExpression
binaryMultiplicativeExpressionWithRight original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryMultiplicativeExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryMultiplicativeExpression"),
              Model.projectionFieldName = (Model.Name "left")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryMultiplicativeExpression"),
              Model.projectionFieldName = (Model.Name "operator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.BinaryNullCoalescingExpression
binaryNullCoalescingExpression :: Typed.TypedTerm Syntax.ConditionalOrExpression -> Typed.TypedTerm Syntax.NullCoalescingExpression -> Typed.TypedTerm Syntax.BinaryNullCoalescingExpression
binaryNullCoalescingExpression left right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryNullCoalescingExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.BinaryNullCoalescingExpression
binaryNullCoalescingExpressionBinaryNullCoalescingExpression :: Typed.TypedName Syntax.BinaryNullCoalescingExpression
binaryNullCoalescingExpressionBinaryNullCoalescingExpression =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BinaryNullCoalescingExpression")

-- | DSL accessor for the left field of hydra.ext.csharp.syntax.BinaryNullCoalescingExpression
binaryNullCoalescingExpressionLeft :: Typed.TypedTerm Syntax.BinaryNullCoalescingExpression -> Typed.TypedTerm Syntax.ConditionalOrExpression
binaryNullCoalescingExpressionLeft x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryNullCoalescingExpression"),
        Model.projectionFieldName = (Model.Name "left")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the right field of hydra.ext.csharp.syntax.BinaryNullCoalescingExpression
binaryNullCoalescingExpressionRight :: Typed.TypedTerm Syntax.BinaryNullCoalescingExpression -> Typed.TypedTerm Syntax.NullCoalescingExpression
binaryNullCoalescingExpressionRight x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryNullCoalescingExpression"),
        Model.projectionFieldName = (Model.Name "right")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the left field of hydra.ext.csharp.syntax.BinaryNullCoalescingExpression
binaryNullCoalescingExpressionWithLeft :: Typed.TypedTerm Syntax.BinaryNullCoalescingExpression -> Typed.TypedTerm Syntax.ConditionalOrExpression -> Typed.TypedTerm Syntax.BinaryNullCoalescingExpression
binaryNullCoalescingExpressionWithLeft original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryNullCoalescingExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryNullCoalescingExpression"),
              Model.projectionFieldName = (Model.Name "right")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the right field of hydra.ext.csharp.syntax.BinaryNullCoalescingExpression
binaryNullCoalescingExpressionWithRight :: Typed.TypedTerm Syntax.BinaryNullCoalescingExpression -> Typed.TypedTerm Syntax.NullCoalescingExpression -> Typed.TypedTerm Syntax.BinaryNullCoalescingExpression
binaryNullCoalescingExpressionWithRight original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryNullCoalescingExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryNullCoalescingExpression"),
              Model.projectionFieldName = (Model.Name "left")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.BinaryOperatorDeclarator
binaryOperatorDeclarator :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.OverloadableBinaryOperator -> Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm Syntax.BinaryOperatorDeclarator
binaryOperatorDeclarator type_ operator left right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Typed.unTypedTerm operator)},
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.BinaryOperatorDeclarator
binaryOperatorDeclaratorBinaryOperatorDeclarator :: Typed.TypedName Syntax.BinaryOperatorDeclarator
binaryOperatorDeclaratorBinaryOperatorDeclarator =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator")

-- | DSL accessor for the left field of hydra.ext.csharp.syntax.BinaryOperatorDeclarator
binaryOperatorDeclaratorLeft :: Typed.TypedTerm Syntax.BinaryOperatorDeclarator -> Typed.TypedTerm Syntax.FixedParameter
binaryOperatorDeclaratorLeft x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"),
        Model.projectionFieldName = (Model.Name "left")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the operator field of hydra.ext.csharp.syntax.BinaryOperatorDeclarator
binaryOperatorDeclaratorOperator :: Typed.TypedTerm Syntax.BinaryOperatorDeclarator -> Typed.TypedTerm Syntax.OverloadableBinaryOperator
binaryOperatorDeclaratorOperator x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"),
        Model.projectionFieldName = (Model.Name "operator")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the right field of hydra.ext.csharp.syntax.BinaryOperatorDeclarator
binaryOperatorDeclaratorRight :: Typed.TypedTerm Syntax.BinaryOperatorDeclarator -> Typed.TypedTerm Syntax.FixedParameter
binaryOperatorDeclaratorRight x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"),
        Model.projectionFieldName = (Model.Name "right")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.BinaryOperatorDeclarator
binaryOperatorDeclaratorType :: Typed.TypedTerm Syntax.BinaryOperatorDeclarator -> Typed.TypedTerm Syntax.Type
binaryOperatorDeclaratorType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the left field of hydra.ext.csharp.syntax.BinaryOperatorDeclarator
binaryOperatorDeclaratorWithLeft :: Typed.TypedTerm Syntax.BinaryOperatorDeclarator -> Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm Syntax.BinaryOperatorDeclarator
binaryOperatorDeclaratorWithLeft original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"),
              Model.projectionFieldName = (Model.Name "operator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"),
              Model.projectionFieldName = (Model.Name "right")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the operator field of hydra.ext.csharp.syntax.BinaryOperatorDeclarator
binaryOperatorDeclaratorWithOperator :: Typed.TypedTerm Syntax.BinaryOperatorDeclarator -> Typed.TypedTerm Syntax.OverloadableBinaryOperator -> Typed.TypedTerm Syntax.BinaryOperatorDeclarator
binaryOperatorDeclaratorWithOperator original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"),
              Model.projectionFieldName = (Model.Name "left")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"),
              Model.projectionFieldName = (Model.Name "right")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the right field of hydra.ext.csharp.syntax.BinaryOperatorDeclarator
binaryOperatorDeclaratorWithRight :: Typed.TypedTerm Syntax.BinaryOperatorDeclarator -> Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm Syntax.BinaryOperatorDeclarator
binaryOperatorDeclaratorWithRight original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"),
              Model.projectionFieldName = (Model.Name "operator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"),
              Model.projectionFieldName = (Model.Name "left")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.BinaryOperatorDeclarator
binaryOperatorDeclaratorWithType :: Typed.TypedTerm Syntax.BinaryOperatorDeclarator -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.BinaryOperatorDeclarator
binaryOperatorDeclaratorWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"),
              Model.projectionFieldName = (Model.Name "operator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"),
              Model.projectionFieldName = (Model.Name "left")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryOperatorDeclarator"),
              Model.projectionFieldName = (Model.Name "right")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.BinaryRelationalExpression
binaryRelationalExpression :: Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.RelationalOperator -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.BinaryRelationalExpression
binaryRelationalExpression left operator right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryRelationalExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Typed.unTypedTerm operator)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.BinaryRelationalExpression
binaryRelationalExpressionBinaryRelationalExpression :: Typed.TypedName Syntax.BinaryRelationalExpression
binaryRelationalExpressionBinaryRelationalExpression =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BinaryRelationalExpression")

-- | DSL accessor for the left field of hydra.ext.csharp.syntax.BinaryRelationalExpression
binaryRelationalExpressionLeft :: Typed.TypedTerm Syntax.BinaryRelationalExpression -> Typed.TypedTerm Syntax.RelationalExpression
binaryRelationalExpressionLeft x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryRelationalExpression"),
        Model.projectionFieldName = (Model.Name "left")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the operator field of hydra.ext.csharp.syntax.BinaryRelationalExpression
binaryRelationalExpressionOperator :: Typed.TypedTerm Syntax.BinaryRelationalExpression -> Typed.TypedTerm Syntax.RelationalOperator
binaryRelationalExpressionOperator x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryRelationalExpression"),
        Model.projectionFieldName = (Model.Name "operator")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the right field of hydra.ext.csharp.syntax.BinaryRelationalExpression
binaryRelationalExpressionRight :: Typed.TypedTerm Syntax.BinaryRelationalExpression -> Typed.TypedTerm Syntax.ShiftExpression
binaryRelationalExpressionRight x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryRelationalExpression"),
        Model.projectionFieldName = (Model.Name "right")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the left field of hydra.ext.csharp.syntax.BinaryRelationalExpression
binaryRelationalExpressionWithLeft :: Typed.TypedTerm Syntax.BinaryRelationalExpression -> Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.BinaryRelationalExpression
binaryRelationalExpressionWithLeft original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryRelationalExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryRelationalExpression"),
              Model.projectionFieldName = (Model.Name "operator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryRelationalExpression"),
              Model.projectionFieldName = (Model.Name "right")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the operator field of hydra.ext.csharp.syntax.BinaryRelationalExpression
binaryRelationalExpressionWithOperator :: Typed.TypedTerm Syntax.BinaryRelationalExpression -> Typed.TypedTerm Syntax.RelationalOperator -> Typed.TypedTerm Syntax.BinaryRelationalExpression
binaryRelationalExpressionWithOperator original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryRelationalExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryRelationalExpression"),
              Model.projectionFieldName = (Model.Name "left")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryRelationalExpression"),
              Model.projectionFieldName = (Model.Name "right")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the right field of hydra.ext.csharp.syntax.BinaryRelationalExpression
binaryRelationalExpressionWithRight :: Typed.TypedTerm Syntax.BinaryRelationalExpression -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.BinaryRelationalExpression
binaryRelationalExpressionWithRight original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryRelationalExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryRelationalExpression"),
              Model.projectionFieldName = (Model.Name "left")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryRelationalExpression"),
              Model.projectionFieldName = (Model.Name "operator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.BinaryShiftExpression
binaryShiftExpression :: Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.ShiftOperator -> Typed.TypedTerm Syntax.AdditiveExpression -> Typed.TypedTerm Syntax.BinaryShiftExpression
binaryShiftExpression left operator right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryShiftExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Typed.unTypedTerm operator)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.BinaryShiftExpression
binaryShiftExpressionBinaryShiftExpression :: Typed.TypedName Syntax.BinaryShiftExpression
binaryShiftExpressionBinaryShiftExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BinaryShiftExpression")

-- | DSL accessor for the left field of hydra.ext.csharp.syntax.BinaryShiftExpression
binaryShiftExpressionLeft :: Typed.TypedTerm Syntax.BinaryShiftExpression -> Typed.TypedTerm Syntax.ShiftExpression
binaryShiftExpressionLeft x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryShiftExpression"),
        Model.projectionFieldName = (Model.Name "left")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the operator field of hydra.ext.csharp.syntax.BinaryShiftExpression
binaryShiftExpressionOperator :: Typed.TypedTerm Syntax.BinaryShiftExpression -> Typed.TypedTerm Syntax.ShiftOperator
binaryShiftExpressionOperator x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryShiftExpression"),
        Model.projectionFieldName = (Model.Name "operator")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the right field of hydra.ext.csharp.syntax.BinaryShiftExpression
binaryShiftExpressionRight :: Typed.TypedTerm Syntax.BinaryShiftExpression -> Typed.TypedTerm Syntax.AdditiveExpression
binaryShiftExpressionRight x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryShiftExpression"),
        Model.projectionFieldName = (Model.Name "right")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the left field of hydra.ext.csharp.syntax.BinaryShiftExpression
binaryShiftExpressionWithLeft :: Typed.TypedTerm Syntax.BinaryShiftExpression -> Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.BinaryShiftExpression
binaryShiftExpressionWithLeft original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryShiftExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryShiftExpression"),
              Model.projectionFieldName = (Model.Name "operator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryShiftExpression"),
              Model.projectionFieldName = (Model.Name "right")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the operator field of hydra.ext.csharp.syntax.BinaryShiftExpression
binaryShiftExpressionWithOperator :: Typed.TypedTerm Syntax.BinaryShiftExpression -> Typed.TypedTerm Syntax.ShiftOperator -> Typed.TypedTerm Syntax.BinaryShiftExpression
binaryShiftExpressionWithOperator original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryShiftExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryShiftExpression"),
              Model.projectionFieldName = (Model.Name "left")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryShiftExpression"),
              Model.projectionFieldName = (Model.Name "right")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the right field of hydra.ext.csharp.syntax.BinaryShiftExpression
binaryShiftExpressionWithRight :: Typed.TypedTerm Syntax.BinaryShiftExpression -> Typed.TypedTerm Syntax.AdditiveExpression -> Typed.TypedTerm Syntax.BinaryShiftExpression
binaryShiftExpressionWithRight original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryShiftExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryShiftExpression"),
              Model.projectionFieldName = (Model.Name "left")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BinaryShiftExpression"),
              Model.projectionFieldName = (Model.Name "operator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for the hydra.ext.csharp.syntax.Block wrapper
block :: Typed.TypedTerm [Syntax.Statement] -> Typed.TypedTerm Syntax.Block
block x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.Block"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.Block
blockBlock :: Typed.TypedName Syntax.Block
blockBlock = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.Block")

-- | DSL constructor for hydra.ext.csharp.syntax.BlockPropertyBody
blockPropertyBody :: Typed.TypedTerm Syntax.AccessorDeclarations -> Typed.TypedTerm (Maybe Syntax.VariableInitializer) -> Typed.TypedTerm Syntax.BlockPropertyBody
blockPropertyBody accessors initializer =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BlockPropertyBody"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "accessors"),
          Model.fieldTerm = (Typed.unTypedTerm accessors)},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Typed.unTypedTerm initializer)}]}))

-- | DSL accessor for the accessors field of hydra.ext.csharp.syntax.BlockPropertyBody
blockPropertyBodyAccessors :: Typed.TypedTerm Syntax.BlockPropertyBody -> Typed.TypedTerm Syntax.AccessorDeclarations
blockPropertyBodyAccessors x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BlockPropertyBody"),
        Model.projectionFieldName = (Model.Name "accessors")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.BlockPropertyBody
blockPropertyBodyBlockPropertyBody :: Typed.TypedName Syntax.BlockPropertyBody
blockPropertyBodyBlockPropertyBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BlockPropertyBody")

-- | DSL accessor for the initializer field of hydra.ext.csharp.syntax.BlockPropertyBody
blockPropertyBodyInitializer :: Typed.TypedTerm Syntax.BlockPropertyBody -> Typed.TypedTerm (Maybe Syntax.VariableInitializer)
blockPropertyBodyInitializer x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BlockPropertyBody"),
        Model.projectionFieldName = (Model.Name "initializer")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the accessors field of hydra.ext.csharp.syntax.BlockPropertyBody
blockPropertyBodyWithAccessors :: Typed.TypedTerm Syntax.BlockPropertyBody -> Typed.TypedTerm Syntax.AccessorDeclarations -> Typed.TypedTerm Syntax.BlockPropertyBody
blockPropertyBodyWithAccessors original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BlockPropertyBody"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "accessors"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BlockPropertyBody"),
              Model.projectionFieldName = (Model.Name "initializer")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the initializer field of hydra.ext.csharp.syntax.BlockPropertyBody
blockPropertyBodyWithInitializer :: Typed.TypedTerm Syntax.BlockPropertyBody -> Typed.TypedTerm (Maybe Syntax.VariableInitializer) -> Typed.TypedTerm Syntax.BlockPropertyBody
blockPropertyBodyWithInitializer original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.BlockPropertyBody"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "accessors"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.BlockPropertyBody"),
              Model.projectionFieldName = (Model.Name "accessors")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for the hydra.ext.csharp.syntax.BooleanExpression wrapper
booleanExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.BooleanExpression
booleanExpression x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.BooleanExpression"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.BooleanExpression
booleanExpressionBooleanExpression :: Typed.TypedName Syntax.BooleanExpression
booleanExpressionBooleanExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.BooleanExpression")

-- | DSL constructor for hydra.ext.csharp.syntax.CastExpression
castExpression :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.CastExpression
castExpression type_ expression =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.CastExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm expression)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.CastExpression
castExpressionCastExpression :: Typed.TypedName Syntax.CastExpression
castExpressionCastExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.CastExpression")

-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.CastExpression
castExpressionExpression :: Typed.TypedTerm Syntax.CastExpression -> Typed.TypedTerm Syntax.UnaryExpression
castExpressionExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CastExpression"),
        Model.projectionFieldName = (Model.Name "expression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.CastExpression
castExpressionType :: Typed.TypedTerm Syntax.CastExpression -> Typed.TypedTerm Syntax.Type
castExpressionType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CastExpression"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the expression field of hydra.ext.csharp.syntax.CastExpression
castExpressionWithExpression :: Typed.TypedTerm Syntax.CastExpression -> Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.CastExpression
castExpressionWithExpression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.CastExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CastExpression"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.CastExpression
castExpressionWithType :: Typed.TypedTerm Syntax.CastExpression -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.CastExpression
castExpressionWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.CastExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CastExpression"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL name token for hydra.ext.csharp.syntax.CatchClauses
catchClausesCatchClauses :: Typed.TypedName Syntax.CatchClauses
catchClausesCatchClauses = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.CatchClauses")

-- | DSL injection for the general variant of hydra.ext.csharp.syntax.CatchClauses
catchClausesGeneral :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.CatchClauses
catchClausesGeneral x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CatchClauses"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "general"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the specific variant of hydra.ext.csharp.syntax.CatchClauses
catchClausesSpecific :: Typed.TypedTerm [Syntax.SpecificCatchClause] -> Typed.TypedTerm Syntax.CatchClauses
catchClausesSpecific x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CatchClauses"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "specific"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the class variant of hydra.ext.csharp.syntax.ClassBase
classBaseClass :: Typed.TypedTerm (Maybe Syntax.ClassType) -> Typed.TypedTerm Syntax.ClassBase
classBaseClass x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassBase"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "class"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.ClassBase
classBaseClassBase :: Typed.TypedName Syntax.ClassBase
classBaseClassBase = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ClassBase")

-- | DSL injection for the interfaces variant of hydra.ext.csharp.syntax.ClassBase
classBaseInterfaces :: Typed.TypedTerm [Syntax.InterfaceType] -> Typed.TypedTerm Syntax.ClassBase
classBaseInterfaces x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassBase"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "interfaces"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for the hydra.ext.csharp.syntax.ClassBody wrapper
classBody :: Typed.TypedTerm [Syntax.ClassMemberDeclaration] -> Typed.TypedTerm Syntax.ClassBody
classBody x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassBody"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.ClassBody
classBodyClassBody :: Typed.TypedName Syntax.ClassBody
classBodyClassBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ClassBody")

-- | DSL constructor for hydra.ext.csharp.syntax.ClassDeclaration
classDeclaration :: Typed.TypedTerm [Syntax.AttributeSection] -> Typed.TypedTerm [Syntax.ClassModifier] -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.TypeParameterList) -> Typed.TypedTerm (Maybe Syntax.ClassBase) -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] -> Typed.TypedTerm Syntax.ClassBody -> Typed.TypedTerm Syntax.ClassDeclaration
classDeclaration attributes modifiers partial name parameters base constraints body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm modifiers)},
        Model.Field {
          Model.fieldName = (Model.Name "partial"),
          Model.fieldTerm = (Typed.unTypedTerm partial)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm parameters)},
        Model.Field {
          Model.fieldName = (Model.Name "base"),
          Model.fieldTerm = (Typed.unTypedTerm base)},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Typed.unTypedTerm constraints)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.ClassDeclaration
classDeclarationAttributes :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm [Syntax.AttributeSection]
classDeclarationAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the base field of hydra.ext.csharp.syntax.ClassDeclaration
classDeclarationBase :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm (Maybe Syntax.ClassBase)
classDeclarationBase x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
        Model.projectionFieldName = (Model.Name "base")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.ClassDeclaration
classDeclarationBody :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm Syntax.ClassBody
classDeclarationBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.ClassDeclaration
classDeclarationClassDeclaration :: Typed.TypedName Syntax.ClassDeclaration
classDeclarationClassDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration")

-- | DSL accessor for the constraints field of hydra.ext.csharp.syntax.ClassDeclaration
classDeclarationConstraints :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause]
classDeclarationConstraints x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
        Model.projectionFieldName = (Model.Name "constraints")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.ClassDeclaration
classDeclarationModifiers :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm [Syntax.ClassModifier]
classDeclarationModifiers x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
        Model.projectionFieldName = (Model.Name "modifiers")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the name field of hydra.ext.csharp.syntax.ClassDeclaration
classDeclarationName :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm Syntax.Identifier
classDeclarationName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the parameters field of hydra.ext.csharp.syntax.ClassDeclaration
classDeclarationParameters :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm (Maybe Syntax.TypeParameterList)
classDeclarationParameters x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
        Model.projectionFieldName = (Model.Name "parameters")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the partial field of hydra.ext.csharp.syntax.ClassDeclaration
classDeclarationPartial :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm Bool
classDeclarationPartial x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
        Model.projectionFieldName = (Model.Name "partial")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.ClassDeclaration
classDeclarationWithAttributes :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm [Syntax.AttributeSection] -> Typed.TypedTerm Syntax.ClassDeclaration
classDeclarationWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "partial"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "partial")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "base"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "base")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the base field of hydra.ext.csharp.syntax.ClassDeclaration
classDeclarationWithBase :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm (Maybe Syntax.ClassBase) -> Typed.TypedTerm Syntax.ClassDeclaration
classDeclarationWithBase original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "partial"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "partial")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "base"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the body field of hydra.ext.csharp.syntax.ClassDeclaration
classDeclarationWithBody :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm Syntax.ClassBody -> Typed.TypedTerm Syntax.ClassDeclaration
classDeclarationWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "partial"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "partial")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "base"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "base")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the constraints field of hydra.ext.csharp.syntax.ClassDeclaration
classDeclarationWithConstraints :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] -> Typed.TypedTerm Syntax.ClassDeclaration
classDeclarationWithConstraints original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "partial"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "partial")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "base"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "base")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.ClassDeclaration
classDeclarationWithModifiers :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm [Syntax.ClassModifier] -> Typed.TypedTerm Syntax.ClassDeclaration
classDeclarationWithModifiers original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "partial"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "partial")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "base"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "base")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.csharp.syntax.ClassDeclaration
classDeclarationWithName :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ClassDeclaration
classDeclarationWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "partial"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "partial")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "base"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "base")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the parameters field of hydra.ext.csharp.syntax.ClassDeclaration
classDeclarationWithParameters :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm (Maybe Syntax.TypeParameterList) -> Typed.TypedTerm Syntax.ClassDeclaration
classDeclarationWithParameters original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "partial"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "partial")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "base"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "base")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the partial field of hydra.ext.csharp.syntax.ClassDeclaration
classDeclarationWithPartial :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.ClassDeclaration
classDeclarationWithPartial original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "partial"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "base"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "base")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL name token for hydra.ext.csharp.syntax.ClassMemberDeclaration
classMemberDeclarationClassMemberDeclaration :: Typed.TypedName Syntax.ClassMemberDeclaration
classMemberDeclarationClassMemberDeclaration =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ClassMemberDeclaration")

-- | DSL injection for the constant variant of hydra.ext.csharp.syntax.ClassMemberDeclaration
classMemberDeclarationConstant :: Typed.TypedTerm Syntax.ConstantDeclaration -> Typed.TypedTerm Syntax.ClassMemberDeclaration
classMemberDeclarationConstant x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassMemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "constant"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the constructor variant of hydra.ext.csharp.syntax.ClassMemberDeclaration
classMemberDeclarationConstructor :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm Syntax.ClassMemberDeclaration
classMemberDeclarationConstructor x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassMemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "constructor"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the event variant of hydra.ext.csharp.syntax.ClassMemberDeclaration
classMemberDeclarationEvent :: Typed.TypedTerm Syntax.EventDeclaration -> Typed.TypedTerm Syntax.ClassMemberDeclaration
classMemberDeclarationEvent x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassMemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "event"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the field variant of hydra.ext.csharp.syntax.ClassMemberDeclaration
classMemberDeclarationField :: Typed.TypedTerm Syntax.FieldDeclaration -> Typed.TypedTerm Syntax.ClassMemberDeclaration
classMemberDeclarationField x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassMemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "field"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the finalizer variant of hydra.ext.csharp.syntax.ClassMemberDeclaration
classMemberDeclarationFinalizer :: Typed.TypedTerm Syntax.FinalizerDeclaration -> Typed.TypedTerm Syntax.ClassMemberDeclaration
classMemberDeclarationFinalizer x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassMemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "finalizer"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the indexer variant of hydra.ext.csharp.syntax.ClassMemberDeclaration
classMemberDeclarationIndexer :: Typed.TypedTerm Syntax.IndexerDeclaration -> Typed.TypedTerm Syntax.ClassMemberDeclaration
classMemberDeclarationIndexer x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassMemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "indexer"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the method variant of hydra.ext.csharp.syntax.ClassMemberDeclaration
classMemberDeclarationMethod :: Typed.TypedTerm Syntax.MethodDeclaration -> Typed.TypedTerm Syntax.ClassMemberDeclaration
classMemberDeclarationMethod x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassMemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "method"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the operator variant of hydra.ext.csharp.syntax.ClassMemberDeclaration
classMemberDeclarationOperator :: Typed.TypedTerm Syntax.OperatorDeclaration -> Typed.TypedTerm Syntax.ClassMemberDeclaration
classMemberDeclarationOperator x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassMemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "operator"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the property variant of hydra.ext.csharp.syntax.ClassMemberDeclaration
classMemberDeclarationProperty :: Typed.TypedTerm Syntax.PropertyDeclaration -> Typed.TypedTerm Syntax.ClassMemberDeclaration
classMemberDeclarationProperty x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassMemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "property"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the staticConstructor variant of hydra.ext.csharp.syntax.ClassMemberDeclaration
classMemberDeclarationStaticConstructor :: Typed.TypedTerm Syntax.StaticConstructorDeclaration -> Typed.TypedTerm Syntax.ClassMemberDeclaration
classMemberDeclarationStaticConstructor x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassMemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "staticConstructor"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the type variant of hydra.ext.csharp.syntax.ClassMemberDeclaration
classMemberDeclarationType :: Typed.TypedTerm Syntax.TypeDeclaration -> Typed.TypedTerm Syntax.ClassMemberDeclaration
classMemberDeclarationType x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassMemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "type"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the abstract variant of hydra.ext.csharp.syntax.ClassModifier
classModifierAbstract :: Typed.TypedTerm Syntax.ClassModifier
classModifierAbstract =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "abstract"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.csharp.syntax.ClassModifier
classModifierClassModifier :: Typed.TypedName Syntax.ClassModifier
classModifierClassModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ClassModifier")

-- | DSL injection for the internal variant of hydra.ext.csharp.syntax.ClassModifier
classModifierInternal :: Typed.TypedTerm Syntax.ClassModifier
classModifierInternal =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "internal"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the new variant of hydra.ext.csharp.syntax.ClassModifier
classModifierNew :: Typed.TypedTerm Syntax.ClassModifier
classModifierNew =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "new"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the private variant of hydra.ext.csharp.syntax.ClassModifier
classModifierPrivate :: Typed.TypedTerm Syntax.ClassModifier
classModifierPrivate =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "private"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the protected variant of hydra.ext.csharp.syntax.ClassModifier
classModifierProtected :: Typed.TypedTerm Syntax.ClassModifier
classModifierProtected =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "protected"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the public variant of hydra.ext.csharp.syntax.ClassModifier
classModifierPublic :: Typed.TypedTerm Syntax.ClassModifier
classModifierPublic =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "public"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the sealed variant of hydra.ext.csharp.syntax.ClassModifier
classModifierSealed :: Typed.TypedTerm Syntax.ClassModifier
classModifierSealed =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "sealed"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the static variant of hydra.ext.csharp.syntax.ClassModifier
classModifierStatic :: Typed.TypedTerm Syntax.ClassModifier
classModifierStatic =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "static"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the unsafe variant of hydra.ext.csharp.syntax.ClassModifier
classModifierUnsafe :: Typed.TypedTerm Syntax.ClassModifier
classModifierUnsafe =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "unsafe"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.csharp.syntax.ClassType
classTypeClassType :: Typed.TypedName Syntax.ClassType
classTypeClassType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ClassType")

-- | DSL injection for the object variant of hydra.ext.csharp.syntax.ClassType
classTypeObject :: Typed.TypedTerm Syntax.ClassType
classTypeObject =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "object"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the string variant of hydra.ext.csharp.syntax.ClassType
classTypeString :: Typed.TypedTerm Syntax.ClassType
classTypeString =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "string"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the typeName variant of hydra.ext.csharp.syntax.ClassType
classTypeTypeName :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.ClassType
classTypeTypeName x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ClassType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "typeName"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.csharp.syntax.CompilationUnit
compilationUnit :: Typed.TypedTerm [Syntax.ExternAliasDirective] -> Typed.TypedTerm [Syntax.UsingDirective] -> Typed.TypedTerm [Syntax.GlobalAttributeSection] -> Typed.TypedTerm [Syntax.NamespaceMemberDeclaration] -> Typed.TypedTerm Syntax.CompilationUnit
compilationUnit externs usings attributes members =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "externs"),
          Model.fieldTerm = (Typed.unTypedTerm externs)},
        Model.Field {
          Model.fieldName = (Model.Name "usings"),
          Model.fieldTerm = (Typed.unTypedTerm usings)},
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "members"),
          Model.fieldTerm = (Typed.unTypedTerm members)}]}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.CompilationUnit
compilationUnitAttributes :: Typed.TypedTerm Syntax.CompilationUnit -> Typed.TypedTerm [Syntax.GlobalAttributeSection]
compilationUnitAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.CompilationUnit
compilationUnitCompilationUnit :: Typed.TypedName Syntax.CompilationUnit
compilationUnitCompilationUnit = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.CompilationUnit")

-- | DSL accessor for the externs field of hydra.ext.csharp.syntax.CompilationUnit
compilationUnitExterns :: Typed.TypedTerm Syntax.CompilationUnit -> Typed.TypedTerm [Syntax.ExternAliasDirective]
compilationUnitExterns x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"),
        Model.projectionFieldName = (Model.Name "externs")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the members field of hydra.ext.csharp.syntax.CompilationUnit
compilationUnitMembers :: Typed.TypedTerm Syntax.CompilationUnit -> Typed.TypedTerm [Syntax.NamespaceMemberDeclaration]
compilationUnitMembers x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"),
        Model.projectionFieldName = (Model.Name "members")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the usings field of hydra.ext.csharp.syntax.CompilationUnit
compilationUnitUsings :: Typed.TypedTerm Syntax.CompilationUnit -> Typed.TypedTerm [Syntax.UsingDirective]
compilationUnitUsings x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"),
        Model.projectionFieldName = (Model.Name "usings")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.CompilationUnit
compilationUnitWithAttributes :: Typed.TypedTerm Syntax.CompilationUnit -> Typed.TypedTerm [Syntax.GlobalAttributeSection] -> Typed.TypedTerm Syntax.CompilationUnit
compilationUnitWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "externs"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"),
              Model.projectionFieldName = (Model.Name "externs")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usings"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"),
              Model.projectionFieldName = (Model.Name "usings")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "members"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"),
              Model.projectionFieldName = (Model.Name "members")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the externs field of hydra.ext.csharp.syntax.CompilationUnit
compilationUnitWithExterns :: Typed.TypedTerm Syntax.CompilationUnit -> Typed.TypedTerm [Syntax.ExternAliasDirective] -> Typed.TypedTerm Syntax.CompilationUnit
compilationUnitWithExterns original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "externs"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "usings"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"),
              Model.projectionFieldName = (Model.Name "usings")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "members"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"),
              Model.projectionFieldName = (Model.Name "members")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the members field of hydra.ext.csharp.syntax.CompilationUnit
compilationUnitWithMembers :: Typed.TypedTerm Syntax.CompilationUnit -> Typed.TypedTerm [Syntax.NamespaceMemberDeclaration] -> Typed.TypedTerm Syntax.CompilationUnit
compilationUnitWithMembers original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "externs"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"),
              Model.projectionFieldName = (Model.Name "externs")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usings"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"),
              Model.projectionFieldName = (Model.Name "usings")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "members"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the usings field of hydra.ext.csharp.syntax.CompilationUnit
compilationUnitWithUsings :: Typed.TypedTerm Syntax.CompilationUnit -> Typed.TypedTerm [Syntax.UsingDirective] -> Typed.TypedTerm Syntax.CompilationUnit
compilationUnitWithUsings original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "externs"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"),
              Model.projectionFieldName = (Model.Name "externs")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usings"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "members"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.CompilationUnit"),
              Model.projectionFieldName = (Model.Name "members")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the binary variant of hydra.ext.csharp.syntax.ConditionalAndExpression
conditionalAndExpressionBinary :: Typed.TypedTerm Syntax.BinaryConditionalAndExpression -> Typed.TypedTerm Syntax.ConditionalAndExpression
conditionalAndExpressionBinary x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConditionalAndExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "binary"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.ConditionalAndExpression
conditionalAndExpressionConditionalAndExpression :: Typed.TypedName Syntax.ConditionalAndExpression
conditionalAndExpressionConditionalAndExpression =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ConditionalAndExpression")

-- | DSL injection for the simple variant of hydra.ext.csharp.syntax.ConditionalAndExpression
conditionalAndExpressionSimple :: Typed.TypedTerm Syntax.InclusiveOrExpression -> Typed.TypedTerm Syntax.ConditionalAndExpression
conditionalAndExpressionSimple x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConditionalAndExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "simple"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.ConditionalExpression
conditionalExpressionConditionalExpression :: Typed.TypedName Syntax.ConditionalExpression
conditionalExpressionConditionalExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ConditionalExpression")

-- | DSL injection for the refConditional variant of hydra.ext.csharp.syntax.ConditionalExpression
conditionalExpressionRefConditional :: Typed.TypedTerm Syntax.RefConditionalExpression -> Typed.TypedTerm Syntax.ConditionalExpression
conditionalExpressionRefConditional x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConditionalExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "refConditional"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the simple variant of hydra.ext.csharp.syntax.ConditionalExpression
conditionalExpressionSimple :: Typed.TypedTerm Syntax.NullCoalescingExpression -> Typed.TypedTerm Syntax.ConditionalExpression
conditionalExpressionSimple x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConditionalExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "simple"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the simpleConditional variant of hydra.ext.csharp.syntax.ConditionalExpression
conditionalExpressionSimpleConditional :: Typed.TypedTerm Syntax.SimpleConditionalExpression -> Typed.TypedTerm Syntax.ConditionalExpression
conditionalExpressionSimpleConditional x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConditionalExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "simpleConditional"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the binary variant of hydra.ext.csharp.syntax.ConditionalOrExpression
conditionalOrExpressionBinary :: Typed.TypedTerm Syntax.BinaryConditionalOrExpression -> Typed.TypedTerm Syntax.ConditionalOrExpression
conditionalOrExpressionBinary x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConditionalOrExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "binary"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.ConditionalOrExpression
conditionalOrExpressionConditionalOrExpression :: Typed.TypedName Syntax.ConditionalOrExpression
conditionalOrExpressionConditionalOrExpression =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ConditionalOrExpression")

-- | DSL injection for the simple variant of hydra.ext.csharp.syntax.ConditionalOrExpression
conditionalOrExpressionSimple :: Typed.TypedTerm Syntax.ConditionalAndExpression -> Typed.TypedTerm Syntax.ConditionalOrExpression
conditionalOrExpressionSimple x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConditionalOrExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "simple"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.csharp.syntax.ConstantDeclaration
constantDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.ConstantModifier] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm [Syntax.ConstantDeclarator] -> Typed.TypedTerm Syntax.ConstantDeclaration
constantDeclaration attributes modifiers type_ declarators =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm modifiers)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Typed.unTypedTerm declarators)}]}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.ConstantDeclaration
constantDeclarationAttributes :: Typed.TypedTerm Syntax.ConstantDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes)
constantDeclarationAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.ConstantDeclaration
constantDeclarationConstantDeclaration :: Typed.TypedName Syntax.ConstantDeclaration
constantDeclarationConstantDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration")

-- | DSL accessor for the declarators field of hydra.ext.csharp.syntax.ConstantDeclaration
constantDeclarationDeclarators :: Typed.TypedTerm Syntax.ConstantDeclaration -> Typed.TypedTerm [Syntax.ConstantDeclarator]
constantDeclarationDeclarators x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"),
        Model.projectionFieldName = (Model.Name "declarators")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.ConstantDeclaration
constantDeclarationModifiers :: Typed.TypedTerm Syntax.ConstantDeclaration -> Typed.TypedTerm [Syntax.ConstantModifier]
constantDeclarationModifiers x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"),
        Model.projectionFieldName = (Model.Name "modifiers")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.ConstantDeclaration
constantDeclarationType :: Typed.TypedTerm Syntax.ConstantDeclaration -> Typed.TypedTerm Syntax.Type
constantDeclarationType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.ConstantDeclaration
constantDeclarationWithAttributes :: Typed.TypedTerm Syntax.ConstantDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.ConstantDeclaration
constantDeclarationWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"),
              Model.projectionFieldName = (Model.Name "declarators")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the declarators field of hydra.ext.csharp.syntax.ConstantDeclaration
constantDeclarationWithDeclarators :: Typed.TypedTerm Syntax.ConstantDeclaration -> Typed.TypedTerm [Syntax.ConstantDeclarator] -> Typed.TypedTerm Syntax.ConstantDeclaration
constantDeclarationWithDeclarators original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.ConstantDeclaration
constantDeclarationWithModifiers :: Typed.TypedTerm Syntax.ConstantDeclaration -> Typed.TypedTerm [Syntax.ConstantModifier] -> Typed.TypedTerm Syntax.ConstantDeclaration
constantDeclarationWithModifiers original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"),
              Model.projectionFieldName = (Model.Name "declarators")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.ConstantDeclaration
constantDeclarationWithType :: Typed.TypedTerm Syntax.ConstantDeclaration -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ConstantDeclaration
constantDeclarationWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclaration"),
              Model.projectionFieldName = (Model.Name "declarators")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.ConstantDeclarator
constantDeclarator :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ConstantExpression -> Typed.TypedTerm Syntax.ConstantDeclarator
constantDeclarator identifier expression =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm identifier)},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm expression)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.ConstantDeclarator
constantDeclaratorConstantDeclarator :: Typed.TypedName Syntax.ConstantDeclarator
constantDeclaratorConstantDeclarator = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ConstantDeclarator")

-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.ConstantDeclarator
constantDeclaratorExpression :: Typed.TypedTerm Syntax.ConstantDeclarator -> Typed.TypedTerm Syntax.ConstantExpression
constantDeclaratorExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclarator"),
        Model.projectionFieldName = (Model.Name "expression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.ConstantDeclarator
constantDeclaratorIdentifier :: Typed.TypedTerm Syntax.ConstantDeclarator -> Typed.TypedTerm Syntax.Identifier
constantDeclaratorIdentifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclarator"),
        Model.projectionFieldName = (Model.Name "identifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the expression field of hydra.ext.csharp.syntax.ConstantDeclarator
constantDeclaratorWithExpression :: Typed.TypedTerm Syntax.ConstantDeclarator -> Typed.TypedTerm Syntax.ConstantExpression -> Typed.TypedTerm Syntax.ConstantDeclarator
constantDeclaratorWithExpression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclarator"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.ConstantDeclarator
constantDeclaratorWithIdentifier :: Typed.TypedTerm Syntax.ConstantDeclarator -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ConstantDeclarator
constantDeclaratorWithIdentifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantDeclarator"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for the hydra.ext.csharp.syntax.ConstantExpression wrapper
constantExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ConstantExpression
constantExpression x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantExpression"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.ConstantExpression
constantExpressionConstantExpression :: Typed.TypedName Syntax.ConstantExpression
constantExpressionConstantExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ConstantExpression")

-- | DSL name token for hydra.ext.csharp.syntax.ConstantModifier
constantModifierConstantModifier :: Typed.TypedName Syntax.ConstantModifier
constantModifierConstantModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ConstantModifier")

-- | DSL injection for the internal variant of hydra.ext.csharp.syntax.ConstantModifier
constantModifierInternal :: Typed.TypedTerm Syntax.ConstantModifier
constantModifierInternal =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "internal"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the new variant of hydra.ext.csharp.syntax.ConstantModifier
constantModifierNew :: Typed.TypedTerm Syntax.ConstantModifier
constantModifierNew =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "new"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the private variant of hydra.ext.csharp.syntax.ConstantModifier
constantModifierPrivate :: Typed.TypedTerm Syntax.ConstantModifier
constantModifierPrivate =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "private"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the protected variant of hydra.ext.csharp.syntax.ConstantModifier
constantModifierProtected :: Typed.TypedTerm Syntax.ConstantModifier
constantModifierProtected =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "protected"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the public variant of hydra.ext.csharp.syntax.ConstantModifier
constantModifierPublic :: Typed.TypedTerm Syntax.ConstantModifier
constantModifierPublic =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstantModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "public"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the block variant of hydra.ext.csharp.syntax.ConstructorBody
constructorBodyBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.ConstructorBody
constructorBodyBlock x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "block"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.ConstructorBody
constructorBodyConstructorBody :: Typed.TypedName Syntax.ConstructorBody
constructorBodyConstructorBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ConstructorBody")

-- | DSL injection for the empty variant of hydra.ext.csharp.syntax.ConstructorBody
constructorBodyEmpty :: Typed.TypedTerm Syntax.ConstructorBody
constructorBodyEmpty =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "empty"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.ConstructorBody
constructorBodyExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ConstructorBody
constructorBodyExpression x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "expression"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.csharp.syntax.ConstructorDeclaration
constructorDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.ConstructorModifier] -> Typed.TypedTerm Syntax.ConstructorDeclarator -> Typed.TypedTerm Syntax.ConstructorBody -> Typed.TypedTerm Syntax.ConstructorDeclaration
constructorDeclaration attributes modifiers declarator body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm modifiers)},
        Model.Field {
          Model.fieldName = (Model.Name "declarator"),
          Model.fieldTerm = (Typed.unTypedTerm declarator)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.ConstructorDeclaration
constructorDeclarationAttributes :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes)
constructorDeclarationAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.ConstructorDeclaration
constructorDeclarationBody :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm Syntax.ConstructorBody
constructorDeclarationBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.ConstructorDeclaration
constructorDeclarationConstructorDeclaration :: Typed.TypedName Syntax.ConstructorDeclaration
constructorDeclarationConstructorDeclaration =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration")

-- | DSL accessor for the declarator field of hydra.ext.csharp.syntax.ConstructorDeclaration
constructorDeclarationDeclarator :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm Syntax.ConstructorDeclarator
constructorDeclarationDeclarator x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"),
        Model.projectionFieldName = (Model.Name "declarator")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.ConstructorDeclaration
constructorDeclarationModifiers :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm [Syntax.ConstructorModifier]
constructorDeclarationModifiers x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"),
        Model.projectionFieldName = (Model.Name "modifiers")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.ConstructorDeclaration
constructorDeclarationWithAttributes :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.ConstructorDeclaration
constructorDeclarationWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "declarator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the body field of hydra.ext.csharp.syntax.ConstructorDeclaration
constructorDeclarationWithBody :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm Syntax.ConstructorBody -> Typed.TypedTerm Syntax.ConstructorDeclaration
constructorDeclarationWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "declarator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the declarator field of hydra.ext.csharp.syntax.ConstructorDeclaration
constructorDeclarationWithDeclarator :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm Syntax.ConstructorDeclarator -> Typed.TypedTerm Syntax.ConstructorDeclaration
constructorDeclarationWithDeclarator original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarator"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.ConstructorDeclaration
constructorDeclarationWithModifiers :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm [Syntax.ConstructorModifier] -> Typed.TypedTerm Syntax.ConstructorDeclaration
constructorDeclarationWithModifiers original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "declarator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "declarator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.ConstructorDeclarator
constructorDeclarator :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.FormalParameterList) -> Typed.TypedTerm (Maybe Syntax.ConstructorInitializer) -> Typed.TypedTerm Syntax.ConstructorDeclarator
constructorDeclarator name parameters initializer =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm parameters)},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Typed.unTypedTerm initializer)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.ConstructorDeclarator
constructorDeclaratorConstructorDeclarator :: Typed.TypedName Syntax.ConstructorDeclarator
constructorDeclaratorConstructorDeclarator = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclarator")

-- | DSL accessor for the initializer field of hydra.ext.csharp.syntax.ConstructorDeclarator
constructorDeclaratorInitializer :: Typed.TypedTerm Syntax.ConstructorDeclarator -> Typed.TypedTerm (Maybe Syntax.ConstructorInitializer)
constructorDeclaratorInitializer x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclarator"),
        Model.projectionFieldName = (Model.Name "initializer")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the name field of hydra.ext.csharp.syntax.ConstructorDeclarator
constructorDeclaratorName :: Typed.TypedTerm Syntax.ConstructorDeclarator -> Typed.TypedTerm Syntax.Identifier
constructorDeclaratorName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclarator"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the parameters field of hydra.ext.csharp.syntax.ConstructorDeclarator
constructorDeclaratorParameters :: Typed.TypedTerm Syntax.ConstructorDeclarator -> Typed.TypedTerm (Maybe Syntax.FormalParameterList)
constructorDeclaratorParameters x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclarator"),
        Model.projectionFieldName = (Model.Name "parameters")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the initializer field of hydra.ext.csharp.syntax.ConstructorDeclarator
constructorDeclaratorWithInitializer :: Typed.TypedTerm Syntax.ConstructorDeclarator -> Typed.TypedTerm (Maybe Syntax.ConstructorInitializer) -> Typed.TypedTerm Syntax.ConstructorDeclarator
constructorDeclaratorWithInitializer original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclarator"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclarator"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the name field of hydra.ext.csharp.syntax.ConstructorDeclarator
constructorDeclaratorWithName :: Typed.TypedTerm Syntax.ConstructorDeclarator -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ConstructorDeclarator
constructorDeclaratorWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclarator"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclarator"),
              Model.projectionFieldName = (Model.Name "initializer")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the parameters field of hydra.ext.csharp.syntax.ConstructorDeclarator
constructorDeclaratorWithParameters :: Typed.TypedTerm Syntax.ConstructorDeclarator -> Typed.TypedTerm (Maybe Syntax.FormalParameterList) -> Typed.TypedTerm Syntax.ConstructorDeclarator
constructorDeclaratorWithParameters original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclarator"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorDeclarator"),
              Model.projectionFieldName = (Model.Name "initializer")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the base variant of hydra.ext.csharp.syntax.ConstructorInitializer
constructorInitializerBase :: Typed.TypedTerm (Maybe Syntax.ArgumentList) -> Typed.TypedTerm Syntax.ConstructorInitializer
constructorInitializerBase x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorInitializer"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "base"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.ConstructorInitializer
constructorInitializerConstructorInitializer :: Typed.TypedName Syntax.ConstructorInitializer
constructorInitializerConstructorInitializer =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ConstructorInitializer")

-- | DSL injection for the this variant of hydra.ext.csharp.syntax.ConstructorInitializer
constructorInitializerThis :: Typed.TypedTerm (Maybe Syntax.ArgumentList) -> Typed.TypedTerm Syntax.ConstructorInitializer
constructorInitializerThis x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorInitializer"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "this"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.ConstructorModifier
constructorModifierConstructorModifier :: Typed.TypedName Syntax.ConstructorModifier
constructorModifierConstructorModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ConstructorModifier")

-- | DSL injection for the extern variant of hydra.ext.csharp.syntax.ConstructorModifier
constructorModifierExtern :: Typed.TypedTerm Syntax.ConstructorModifier
constructorModifierExtern =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "extern"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the internal variant of hydra.ext.csharp.syntax.ConstructorModifier
constructorModifierInternal :: Typed.TypedTerm Syntax.ConstructorModifier
constructorModifierInternal =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "internal"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the private variant of hydra.ext.csharp.syntax.ConstructorModifier
constructorModifierPrivate :: Typed.TypedTerm Syntax.ConstructorModifier
constructorModifierPrivate =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "private"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the protected variant of hydra.ext.csharp.syntax.ConstructorModifier
constructorModifierProtected :: Typed.TypedTerm Syntax.ConstructorModifier
constructorModifierProtected =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "protected"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the public variant of hydra.ext.csharp.syntax.ConstructorModifier
constructorModifierPublic :: Typed.TypedTerm Syntax.ConstructorModifier
constructorModifierPublic =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "public"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the unsafe variant of hydra.ext.csharp.syntax.ConstructorModifier
constructorModifierUnsafe :: Typed.TypedTerm Syntax.ConstructorModifier
constructorModifierUnsafe =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConstructorModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "unsafe"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.csharp.syntax.ConversionKind
conversionKindConversionKind :: Typed.TypedName Syntax.ConversionKind
conversionKindConversionKind = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ConversionKind")

-- | DSL injection for the explicit variant of hydra.ext.csharp.syntax.ConversionKind
conversionKindExplicit :: Typed.TypedTerm Syntax.ConversionKind
conversionKindExplicit =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConversionKind"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "explicit"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the implicit variant of hydra.ext.csharp.syntax.ConversionKind
conversionKindImplicit :: Typed.TypedTerm Syntax.ConversionKind
conversionKindImplicit =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConversionKind"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "implicit"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL constructor for hydra.ext.csharp.syntax.ConversionOperatorDeclarator
conversionOperatorDeclarator :: Typed.TypedTerm Syntax.ConversionKind -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm Syntax.ConversionOperatorDeclarator
conversionOperatorDeclarator kind type_ parameter =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConversionOperatorDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "kind"),
          Model.fieldTerm = (Typed.unTypedTerm kind)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "parameter"),
          Model.fieldTerm = (Typed.unTypedTerm parameter)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.ConversionOperatorDeclarator
conversionOperatorDeclaratorConversionOperatorDeclarator :: Typed.TypedName Syntax.ConversionOperatorDeclarator
conversionOperatorDeclaratorConversionOperatorDeclarator =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ConversionOperatorDeclarator")

-- | DSL accessor for the kind field of hydra.ext.csharp.syntax.ConversionOperatorDeclarator
conversionOperatorDeclaratorKind :: Typed.TypedTerm Syntax.ConversionOperatorDeclarator -> Typed.TypedTerm Syntax.ConversionKind
conversionOperatorDeclaratorKind x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConversionOperatorDeclarator"),
        Model.projectionFieldName = (Model.Name "kind")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the parameter field of hydra.ext.csharp.syntax.ConversionOperatorDeclarator
conversionOperatorDeclaratorParameter :: Typed.TypedTerm Syntax.ConversionOperatorDeclarator -> Typed.TypedTerm Syntax.FixedParameter
conversionOperatorDeclaratorParameter x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConversionOperatorDeclarator"),
        Model.projectionFieldName = (Model.Name "parameter")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.ConversionOperatorDeclarator
conversionOperatorDeclaratorType :: Typed.TypedTerm Syntax.ConversionOperatorDeclarator -> Typed.TypedTerm Syntax.Type
conversionOperatorDeclaratorType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConversionOperatorDeclarator"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the kind field of hydra.ext.csharp.syntax.ConversionOperatorDeclarator
conversionOperatorDeclaratorWithKind :: Typed.TypedTerm Syntax.ConversionOperatorDeclarator -> Typed.TypedTerm Syntax.ConversionKind -> Typed.TypedTerm Syntax.ConversionOperatorDeclarator
conversionOperatorDeclaratorWithKind original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConversionOperatorDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "kind"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConversionOperatorDeclarator"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameter"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConversionOperatorDeclarator"),
              Model.projectionFieldName = (Model.Name "parameter")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the parameter field of hydra.ext.csharp.syntax.ConversionOperatorDeclarator
conversionOperatorDeclaratorWithParameter :: Typed.TypedTerm Syntax.ConversionOperatorDeclarator -> Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm Syntax.ConversionOperatorDeclarator
conversionOperatorDeclaratorWithParameter original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConversionOperatorDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "kind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConversionOperatorDeclarator"),
              Model.projectionFieldName = (Model.Name "kind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConversionOperatorDeclarator"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameter"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.ConversionOperatorDeclarator
conversionOperatorDeclaratorWithType :: Typed.TypedTerm Syntax.ConversionOperatorDeclarator -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ConversionOperatorDeclarator
conversionOperatorDeclaratorWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ConversionOperatorDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "kind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConversionOperatorDeclarator"),
              Model.projectionFieldName = (Model.Name "kind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "parameter"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ConversionOperatorDeclarator"),
              Model.projectionFieldName = (Model.Name "parameter")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.DeclarationExpression
declarationExpression :: Typed.TypedTerm Syntax.LocalVariableType -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.DeclarationExpression
declarationExpression type_ identifier =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm identifier)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.DeclarationExpression
declarationExpressionDeclarationExpression :: Typed.TypedName Syntax.DeclarationExpression
declarationExpressionDeclarationExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.DeclarationExpression")

-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.DeclarationExpression
declarationExpressionIdentifier :: Typed.TypedTerm Syntax.DeclarationExpression -> Typed.TypedTerm Syntax.Identifier
declarationExpressionIdentifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationExpression"),
        Model.projectionFieldName = (Model.Name "identifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.DeclarationExpression
declarationExpressionType :: Typed.TypedTerm Syntax.DeclarationExpression -> Typed.TypedTerm Syntax.LocalVariableType
declarationExpressionType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationExpression"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.DeclarationExpression
declarationExpressionWithIdentifier :: Typed.TypedTerm Syntax.DeclarationExpression -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.DeclarationExpression
declarationExpressionWithIdentifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationExpression"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.DeclarationExpression
declarationExpressionWithType :: Typed.TypedTerm Syntax.DeclarationExpression -> Typed.TypedTerm Syntax.LocalVariableType -> Typed.TypedTerm Syntax.DeclarationExpression
declarationExpressionWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationExpression"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.DeclarationPattern
declarationPattern :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Designation -> Typed.TypedTerm Syntax.DeclarationPattern
declarationPattern type_ designation =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationPattern"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "designation"),
          Model.fieldTerm = (Typed.unTypedTerm designation)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.DeclarationPattern
declarationPatternDeclarationPattern :: Typed.TypedName Syntax.DeclarationPattern
declarationPatternDeclarationPattern = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.DeclarationPattern")

-- | DSL accessor for the designation field of hydra.ext.csharp.syntax.DeclarationPattern
declarationPatternDesignation :: Typed.TypedTerm Syntax.DeclarationPattern -> Typed.TypedTerm Syntax.Designation
declarationPatternDesignation x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationPattern"),
        Model.projectionFieldName = (Model.Name "designation")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.DeclarationPattern
declarationPatternType :: Typed.TypedTerm Syntax.DeclarationPattern -> Typed.TypedTerm Syntax.Type
declarationPatternType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationPattern"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the designation field of hydra.ext.csharp.syntax.DeclarationPattern
declarationPatternWithDesignation :: Typed.TypedTerm Syntax.DeclarationPattern -> Typed.TypedTerm Syntax.Designation -> Typed.TypedTerm Syntax.DeclarationPattern
declarationPatternWithDesignation original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationPattern"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationPattern"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "designation"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.DeclarationPattern
declarationPatternWithType :: Typed.TypedTerm Syntax.DeclarationPattern -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.DeclarationPattern
declarationPatternWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationPattern"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "designation"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationPattern"),
              Model.projectionFieldName = (Model.Name "designation")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the constant variant of hydra.ext.csharp.syntax.DeclarationStatement
declarationStatementConstant :: Typed.TypedTerm Syntax.LocalConstantDeclaration -> Typed.TypedTerm Syntax.DeclarationStatement
declarationStatementConstant x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "constant"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.DeclarationStatement
declarationStatementDeclarationStatement :: Typed.TypedName Syntax.DeclarationStatement
declarationStatementDeclarationStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.DeclarationStatement")

-- | DSL injection for the function variant of hydra.ext.csharp.syntax.DeclarationStatement
declarationStatementFunction :: Typed.TypedTerm Syntax.LocalFunctionDeclaration -> Typed.TypedTerm Syntax.DeclarationStatement
declarationStatementFunction x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "function"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the variable variant of hydra.ext.csharp.syntax.DeclarationStatement
declarationStatementVariable :: Typed.TypedTerm Syntax.LocalVariableDeclaration -> Typed.TypedTerm Syntax.DeclarationStatement
declarationStatementVariable x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DeclarationStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "variable"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.DeconstructionElement
deconstructionElementDeconstructionElement :: Typed.TypedName Syntax.DeconstructionElement
deconstructionElementDeconstructionElement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.DeconstructionElement")

-- | DSL injection for the identifier variant of hydra.ext.csharp.syntax.DeconstructionElement
deconstructionElementIdentifier :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.DeconstructionElement
deconstructionElementIdentifier x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DeconstructionElement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "identifier"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the tuple variant of hydra.ext.csharp.syntax.DeconstructionElement
deconstructionElementTuple :: Typed.TypedTerm Syntax.DeconstructionTuple -> Typed.TypedTerm Syntax.DeconstructionElement
deconstructionElementTuple x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DeconstructionElement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "tuple"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for the hydra.ext.csharp.syntax.DeconstructionTuple wrapper
deconstructionTuple :: Typed.TypedTerm [Syntax.DeconstructionElement] -> Typed.TypedTerm Syntax.DeconstructionTuple
deconstructionTuple x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.DeconstructionTuple"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.DeconstructionTuple
deconstructionTupleDeconstructionTuple :: Typed.TypedName Syntax.DeconstructionTuple
deconstructionTupleDeconstructionTuple = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.DeconstructionTuple")

-- | DSL injection for the defaultLiteral variant of hydra.ext.csharp.syntax.DefaultValueExpression
defaultValueExpressionDefaultLiteral :: Typed.TypedTerm Syntax.DefaultValueExpression
defaultValueExpressionDefaultLiteral =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DefaultValueExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "defaultLiteral"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.csharp.syntax.DefaultValueExpression
defaultValueExpressionDefaultValueExpression :: Typed.TypedName Syntax.DefaultValueExpression
defaultValueExpressionDefaultValueExpression =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.DefaultValueExpression")

-- | DSL injection for the explicitlyTyped variant of hydra.ext.csharp.syntax.DefaultValueExpression
defaultValueExpressionExplicitlyTyped :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.DefaultValueExpression
defaultValueExpressionExplicitlyTyped x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DefaultValueExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "explicitlyTyped"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.csharp.syntax.DelegateCreationExpression
delegateCreationExpression :: Typed.TypedTerm Syntax.DelegateType -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.DelegateCreationExpression
delegateCreationExpression type_ expression =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateCreationExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm expression)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.DelegateCreationExpression
delegateCreationExpressionDelegateCreationExpression :: Typed.TypedName Syntax.DelegateCreationExpression
delegateCreationExpressionDelegateCreationExpression =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.DelegateCreationExpression")

-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.DelegateCreationExpression
delegateCreationExpressionExpression :: Typed.TypedTerm Syntax.DelegateCreationExpression -> Typed.TypedTerm Syntax.Expression
delegateCreationExpressionExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateCreationExpression"),
        Model.projectionFieldName = (Model.Name "expression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.DelegateCreationExpression
delegateCreationExpressionType :: Typed.TypedTerm Syntax.DelegateCreationExpression -> Typed.TypedTerm Syntax.DelegateType
delegateCreationExpressionType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateCreationExpression"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the expression field of hydra.ext.csharp.syntax.DelegateCreationExpression
delegateCreationExpressionWithExpression :: Typed.TypedTerm Syntax.DelegateCreationExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.DelegateCreationExpression
delegateCreationExpressionWithExpression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateCreationExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateCreationExpression"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.DelegateCreationExpression
delegateCreationExpressionWithType :: Typed.TypedTerm Syntax.DelegateCreationExpression -> Typed.TypedTerm Syntax.DelegateType -> Typed.TypedTerm Syntax.DelegateCreationExpression
delegateCreationExpressionWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateCreationExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateCreationExpression"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.DelegateDeclaration
delegateDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.DelegateModifier] -> Typed.TypedTerm Syntax.ReturnType -> Typed.TypedTerm (Maybe Syntax.RefKind) -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.DelegateHeader -> Typed.TypedTerm Syntax.DelegateDeclaration
delegateDeclaration attributes modifiers returnType refKind refReturnType header =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm modifiers)},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Typed.unTypedTerm returnType)},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Typed.unTypedTerm refKind)},
        Model.Field {
          Model.fieldName = (Model.Name "refReturnType"),
          Model.fieldTerm = (Typed.unTypedTerm refReturnType)},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Typed.unTypedTerm header)}]}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.DelegateDeclaration
delegateDeclarationAttributes :: Typed.TypedTerm Syntax.DelegateDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes)
delegateDeclarationAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.DelegateDeclaration
delegateDeclarationDelegateDeclaration :: Typed.TypedName Syntax.DelegateDeclaration
delegateDeclarationDelegateDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration")

-- | DSL accessor for the header field of hydra.ext.csharp.syntax.DelegateDeclaration
delegateDeclarationHeader :: Typed.TypedTerm Syntax.DelegateDeclaration -> Typed.TypedTerm Syntax.DelegateHeader
delegateDeclarationHeader x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
        Model.projectionFieldName = (Model.Name "header")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.DelegateDeclaration
delegateDeclarationModifiers :: Typed.TypedTerm Syntax.DelegateDeclaration -> Typed.TypedTerm [Syntax.DelegateModifier]
delegateDeclarationModifiers x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
        Model.projectionFieldName = (Model.Name "modifiers")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the refKind field of hydra.ext.csharp.syntax.DelegateDeclaration
delegateDeclarationRefKind :: Typed.TypedTerm Syntax.DelegateDeclaration -> Typed.TypedTerm (Maybe Syntax.RefKind)
delegateDeclarationRefKind x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
        Model.projectionFieldName = (Model.Name "refKind")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the refReturnType field of hydra.ext.csharp.syntax.DelegateDeclaration
delegateDeclarationRefReturnType :: Typed.TypedTerm Syntax.DelegateDeclaration -> Typed.TypedTerm (Maybe Syntax.Type)
delegateDeclarationRefReturnType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
        Model.projectionFieldName = (Model.Name "refReturnType")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the returnType field of hydra.ext.csharp.syntax.DelegateDeclaration
delegateDeclarationReturnType :: Typed.TypedTerm Syntax.DelegateDeclaration -> Typed.TypedTerm Syntax.ReturnType
delegateDeclarationReturnType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
        Model.projectionFieldName = (Model.Name "returnType")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.DelegateDeclaration
delegateDeclarationWithAttributes :: Typed.TypedTerm Syntax.DelegateDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.DelegateDeclaration
delegateDeclarationWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refReturnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
              Model.projectionFieldName = (Model.Name "refReturnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
              Model.projectionFieldName = (Model.Name "header")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the header field of hydra.ext.csharp.syntax.DelegateDeclaration
delegateDeclarationWithHeader :: Typed.TypedTerm Syntax.DelegateDeclaration -> Typed.TypedTerm Syntax.DelegateHeader -> Typed.TypedTerm Syntax.DelegateDeclaration
delegateDeclarationWithHeader original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refReturnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
              Model.projectionFieldName = (Model.Name "refReturnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.DelegateDeclaration
delegateDeclarationWithModifiers :: Typed.TypedTerm Syntax.DelegateDeclaration -> Typed.TypedTerm [Syntax.DelegateModifier] -> Typed.TypedTerm Syntax.DelegateDeclaration
delegateDeclarationWithModifiers original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refReturnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
              Model.projectionFieldName = (Model.Name "refReturnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
              Model.projectionFieldName = (Model.Name "header")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the refKind field of hydra.ext.csharp.syntax.DelegateDeclaration
delegateDeclarationWithRefKind :: Typed.TypedTerm Syntax.DelegateDeclaration -> Typed.TypedTerm (Maybe Syntax.RefKind) -> Typed.TypedTerm Syntax.DelegateDeclaration
delegateDeclarationWithRefKind original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "refReturnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
              Model.projectionFieldName = (Model.Name "refReturnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
              Model.projectionFieldName = (Model.Name "header")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the refReturnType field of hydra.ext.csharp.syntax.DelegateDeclaration
delegateDeclarationWithRefReturnType :: Typed.TypedTerm Syntax.DelegateDeclaration -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.DelegateDeclaration
delegateDeclarationWithRefReturnType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refReturnType"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
              Model.projectionFieldName = (Model.Name "header")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the returnType field of hydra.ext.csharp.syntax.DelegateDeclaration
delegateDeclarationWithReturnType :: Typed.TypedTerm Syntax.DelegateDeclaration -> Typed.TypedTerm Syntax.ReturnType -> Typed.TypedTerm Syntax.DelegateDeclaration
delegateDeclarationWithReturnType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refReturnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
              Model.projectionFieldName = (Model.Name "refReturnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateDeclaration"),
              Model.projectionFieldName = (Model.Name "header")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.DelegateHeader
delegateHeader :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.VariantTypeParameters) -> Typed.TypedTerm (Maybe Syntax.FormalParameterList) -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] -> Typed.TypedTerm Syntax.DelegateHeader
delegateHeader name typeParameters parameters constraints =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "typeParameters"),
          Model.fieldTerm = (Typed.unTypedTerm typeParameters)},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm parameters)},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Typed.unTypedTerm constraints)}]}))

-- | DSL accessor for the constraints field of hydra.ext.csharp.syntax.DelegateHeader
delegateHeaderConstraints :: Typed.TypedTerm Syntax.DelegateHeader -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause]
delegateHeaderConstraints x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"),
        Model.projectionFieldName = (Model.Name "constraints")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.DelegateHeader
delegateHeaderDelegateHeader :: Typed.TypedName Syntax.DelegateHeader
delegateHeaderDelegateHeader = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.DelegateHeader")

-- | DSL accessor for the name field of hydra.ext.csharp.syntax.DelegateHeader
delegateHeaderName :: Typed.TypedTerm Syntax.DelegateHeader -> Typed.TypedTerm Syntax.Identifier
delegateHeaderName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the parameters field of hydra.ext.csharp.syntax.DelegateHeader
delegateHeaderParameters :: Typed.TypedTerm Syntax.DelegateHeader -> Typed.TypedTerm (Maybe Syntax.FormalParameterList)
delegateHeaderParameters x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"),
        Model.projectionFieldName = (Model.Name "parameters")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the typeParameters field of hydra.ext.csharp.syntax.DelegateHeader
delegateHeaderTypeParameters :: Typed.TypedTerm Syntax.DelegateHeader -> Typed.TypedTerm (Maybe Syntax.VariantTypeParameters)
delegateHeaderTypeParameters x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"),
        Model.projectionFieldName = (Model.Name "typeParameters")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the constraints field of hydra.ext.csharp.syntax.DelegateHeader
delegateHeaderWithConstraints :: Typed.TypedTerm Syntax.DelegateHeader -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] -> Typed.TypedTerm Syntax.DelegateHeader
delegateHeaderWithConstraints original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeParameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"),
              Model.projectionFieldName = (Model.Name "typeParameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the name field of hydra.ext.csharp.syntax.DelegateHeader
delegateHeaderWithName :: Typed.TypedTerm Syntax.DelegateHeader -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.DelegateHeader
delegateHeaderWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "typeParameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"),
              Model.projectionFieldName = (Model.Name "typeParameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the parameters field of hydra.ext.csharp.syntax.DelegateHeader
delegateHeaderWithParameters :: Typed.TypedTerm Syntax.DelegateHeader -> Typed.TypedTerm (Maybe Syntax.FormalParameterList) -> Typed.TypedTerm Syntax.DelegateHeader
delegateHeaderWithParameters original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeParameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"),
              Model.projectionFieldName = (Model.Name "typeParameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the typeParameters field of hydra.ext.csharp.syntax.DelegateHeader
delegateHeaderWithTypeParameters :: Typed.TypedTerm Syntax.DelegateHeader -> Typed.TypedTerm (Maybe Syntax.VariantTypeParameters) -> Typed.TypedTerm Syntax.DelegateHeader
delegateHeaderWithTypeParameters original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeParameters"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateHeader"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL name token for hydra.ext.csharp.syntax.DelegateModifier
delegateModifierDelegateModifier :: Typed.TypedName Syntax.DelegateModifier
delegateModifierDelegateModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.DelegateModifier")

-- | DSL injection for the internal variant of hydra.ext.csharp.syntax.DelegateModifier
delegateModifierInternal :: Typed.TypedTerm Syntax.DelegateModifier
delegateModifierInternal =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "internal"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the new variant of hydra.ext.csharp.syntax.DelegateModifier
delegateModifierNew :: Typed.TypedTerm Syntax.DelegateModifier
delegateModifierNew =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "new"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the private variant of hydra.ext.csharp.syntax.DelegateModifier
delegateModifierPrivate :: Typed.TypedTerm Syntax.DelegateModifier
delegateModifierPrivate =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "private"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the protected variant of hydra.ext.csharp.syntax.DelegateModifier
delegateModifierProtected :: Typed.TypedTerm Syntax.DelegateModifier
delegateModifierProtected =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "protected"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the public variant of hydra.ext.csharp.syntax.DelegateModifier
delegateModifierPublic :: Typed.TypedTerm Syntax.DelegateModifier
delegateModifierPublic =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "public"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the unsafe variant of hydra.ext.csharp.syntax.DelegateModifier
delegateModifierUnsafe :: Typed.TypedTerm Syntax.DelegateModifier
delegateModifierUnsafe =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "unsafe"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL constructor for the hydra.ext.csharp.syntax.DelegateType wrapper
delegateType :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.DelegateType
delegateType x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.DelegateType"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.DelegateType
delegateTypeDelegateType :: Typed.TypedName Syntax.DelegateType
delegateTypeDelegateType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.DelegateType")

-- | DSL name token for hydra.ext.csharp.syntax.DependentAccess
dependentAccessDependentAccess :: Typed.TypedName Syntax.DependentAccess
dependentAccessDependentAccess = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.DependentAccess")

-- | DSL injection for the elementAccess variant of hydra.ext.csharp.syntax.DependentAccess
dependentAccessElementAccess :: Typed.TypedTerm Syntax.ArgumentList -> Typed.TypedTerm Syntax.DependentAccess
dependentAccessElementAccess x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DependentAccess"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "elementAccess"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.csharp.syntax.DependentAccessForMember
dependentAccessForMember :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.DependentAccessForMember
dependentAccessForMember identifier typeArguments =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DependentAccessForMember"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm identifier)},
        Model.Field {
          Model.fieldName = (Model.Name "typeArguments"),
          Model.fieldTerm = (Typed.unTypedTerm typeArguments)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.DependentAccessForMember
dependentAccessForMemberDependentAccessForMember :: Typed.TypedName Syntax.DependentAccessForMember
dependentAccessForMemberDependentAccessForMember =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.DependentAccessForMember")

-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.DependentAccessForMember
dependentAccessForMemberIdentifier :: Typed.TypedTerm Syntax.DependentAccessForMember -> Typed.TypedTerm Syntax.Identifier
dependentAccessForMemberIdentifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DependentAccessForMember"),
        Model.projectionFieldName = (Model.Name "identifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the typeArguments field of hydra.ext.csharp.syntax.DependentAccessForMember
dependentAccessForMemberTypeArguments :: Typed.TypedTerm Syntax.DependentAccessForMember -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList)
dependentAccessForMemberTypeArguments x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DependentAccessForMember"),
        Model.projectionFieldName = (Model.Name "typeArguments")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.DependentAccessForMember
dependentAccessForMemberWithIdentifier :: Typed.TypedTerm Syntax.DependentAccessForMember -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.DependentAccessForMember
dependentAccessForMemberWithIdentifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DependentAccessForMember"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "typeArguments"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DependentAccessForMember"),
              Model.projectionFieldName = (Model.Name "typeArguments")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the typeArguments field of hydra.ext.csharp.syntax.DependentAccessForMember
dependentAccessForMemberWithTypeArguments :: Typed.TypedTerm Syntax.DependentAccessForMember -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.DependentAccessForMember
dependentAccessForMemberWithTypeArguments original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DependentAccessForMember"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DependentAccessForMember"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeArguments"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the invocation variant of hydra.ext.csharp.syntax.DependentAccess
dependentAccessInvocation :: Typed.TypedTerm (Maybe Syntax.ArgumentList) -> Typed.TypedTerm Syntax.DependentAccess
dependentAccessInvocation x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DependentAccess"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "invocation"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the memberAccess variant of hydra.ext.csharp.syntax.DependentAccess
dependentAccessMemberAccess :: Typed.TypedTerm Syntax.DependentAccessForMember -> Typed.TypedTerm Syntax.DependentAccess
dependentAccessMemberAccess x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DependentAccess"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "memberAccess"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for the hydra.ext.csharp.syntax.Designation wrapper
designation :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.Designation
designation x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.Designation"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.Designation
designationDesignation :: Typed.TypedName Syntax.Designation
designationDesignation = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.Designation")

-- | DSL constructor for hydra.ext.csharp.syntax.DoStatement
doStatement :: Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.BooleanExpression -> Typed.TypedTerm Syntax.DoStatement
doStatement body while =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DoStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)},
        Model.Field {
          Model.fieldName = (Model.Name "while"),
          Model.fieldTerm = (Typed.unTypedTerm while)}]}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.DoStatement
doStatementBody :: Typed.TypedTerm Syntax.DoStatement -> Typed.TypedTerm Syntax.EmbeddedStatement
doStatementBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DoStatement"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.DoStatement
doStatementDoStatement :: Typed.TypedName Syntax.DoStatement
doStatementDoStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.DoStatement")

-- | DSL accessor for the while field of hydra.ext.csharp.syntax.DoStatement
doStatementWhile :: Typed.TypedTerm Syntax.DoStatement -> Typed.TypedTerm Syntax.BooleanExpression
doStatementWhile x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DoStatement"),
        Model.projectionFieldName = (Model.Name "while")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the body field of hydra.ext.csharp.syntax.DoStatement
doStatementWithBody :: Typed.TypedTerm Syntax.DoStatement -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.DoStatement
doStatementWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DoStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "while"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DoStatement"),
              Model.projectionFieldName = (Model.Name "while")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the while field of hydra.ext.csharp.syntax.DoStatement
doStatementWithWhile :: Typed.TypedTerm Syntax.DoStatement -> Typed.TypedTerm Syntax.BooleanExpression -> Typed.TypedTerm Syntax.DoStatement
doStatementWithWhile original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.DoStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.DoStatement"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "while"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.ElementAccess
elementAccess :: Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression -> Typed.TypedTerm Syntax.ArgumentList -> Typed.TypedTerm Syntax.ElementAccess
elementAccess expression arguments =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ElementAccess"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm expression)},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Typed.unTypedTerm arguments)}]}))

-- | DSL accessor for the arguments field of hydra.ext.csharp.syntax.ElementAccess
elementAccessArguments :: Typed.TypedTerm Syntax.ElementAccess -> Typed.TypedTerm Syntax.ArgumentList
elementAccessArguments x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ElementAccess"),
        Model.projectionFieldName = (Model.Name "arguments")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.ElementAccess
elementAccessElementAccess :: Typed.TypedName Syntax.ElementAccess
elementAccessElementAccess = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ElementAccess")

-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.ElementAccess
elementAccessExpression :: Typed.TypedTerm Syntax.ElementAccess -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression
elementAccessExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ElementAccess"),
        Model.projectionFieldName = (Model.Name "expression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the arguments field of hydra.ext.csharp.syntax.ElementAccess
elementAccessWithArguments :: Typed.TypedTerm Syntax.ElementAccess -> Typed.TypedTerm Syntax.ArgumentList -> Typed.TypedTerm Syntax.ElementAccess
elementAccessWithArguments original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ElementAccess"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ElementAccess"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the expression field of hydra.ext.csharp.syntax.ElementAccess
elementAccessWithExpression :: Typed.TypedTerm Syntax.ElementAccess -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression -> Typed.TypedTerm Syntax.ElementAccess
elementAccessWithExpression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ElementAccess"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ElementAccess"),
              Model.projectionFieldName = (Model.Name "arguments")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL name token for hydra.ext.csharp.syntax.ElementInitializer
elementInitializerElementInitializer :: Typed.TypedName Syntax.ElementInitializer
elementInitializerElementInitializer = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ElementInitializer")

-- | DSL injection for the list variant of hydra.ext.csharp.syntax.ElementInitializer
elementInitializerList :: Typed.TypedTerm Syntax.ExpressionList -> Typed.TypedTerm Syntax.ElementInitializer
elementInitializerList x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ElementInitializer"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "list"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the single variant of hydra.ext.csharp.syntax.ElementInitializer
elementInitializerSingle :: Typed.TypedTerm Syntax.NonAssignmentExpression -> Typed.TypedTerm Syntax.ElementInitializer
elementInitializerSingle x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ElementInitializer"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "single"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the block variant of hydra.ext.csharp.syntax.EmbeddedStatement
embeddedStatementBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.EmbeddedStatement
embeddedStatementBlock x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EmbeddedStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "block"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the checked variant of hydra.ext.csharp.syntax.EmbeddedStatement
embeddedStatementChecked :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.EmbeddedStatement
embeddedStatementChecked x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EmbeddedStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "checked"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.EmbeddedStatement
embeddedStatementEmbeddedStatement :: Typed.TypedName Syntax.EmbeddedStatement
embeddedStatementEmbeddedStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.EmbeddedStatement")

-- | DSL injection for the empty variant of hydra.ext.csharp.syntax.EmbeddedStatement
embeddedStatementEmpty :: Typed.TypedTerm Syntax.EmbeddedStatement
embeddedStatementEmpty =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EmbeddedStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "empty"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.EmbeddedStatement
embeddedStatementExpression :: Typed.TypedTerm Syntax.StatementExpression -> Typed.TypedTerm Syntax.EmbeddedStatement
embeddedStatementExpression x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EmbeddedStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "expression"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the fixed variant of hydra.ext.csharp.syntax.EmbeddedStatement
embeddedStatementFixed :: Typed.TypedTerm Syntax.FixedStatement -> Typed.TypedTerm Syntax.EmbeddedStatement
embeddedStatementFixed x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EmbeddedStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "fixed"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the iteration variant of hydra.ext.csharp.syntax.EmbeddedStatement
embeddedStatementIteration :: Typed.TypedTerm Syntax.IterationStatement -> Typed.TypedTerm Syntax.EmbeddedStatement
embeddedStatementIteration x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EmbeddedStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "iteration"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the jump variant of hydra.ext.csharp.syntax.EmbeddedStatement
embeddedStatementJump :: Typed.TypedTerm Syntax.JumpStatement -> Typed.TypedTerm Syntax.EmbeddedStatement
embeddedStatementJump x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EmbeddedStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "jump"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the lock variant of hydra.ext.csharp.syntax.EmbeddedStatement
embeddedStatementLock :: Typed.TypedTerm Syntax.LockStatement -> Typed.TypedTerm Syntax.EmbeddedStatement
embeddedStatementLock x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EmbeddedStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "lock"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the selection variant of hydra.ext.csharp.syntax.EmbeddedStatement
embeddedStatementSelection :: Typed.TypedTerm Syntax.SelectionStatement -> Typed.TypedTerm Syntax.EmbeddedStatement
embeddedStatementSelection x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EmbeddedStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "selection"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the try variant of hydra.ext.csharp.syntax.EmbeddedStatement
embeddedStatementTry :: Typed.TypedTerm Syntax.TryStatement -> Typed.TypedTerm Syntax.EmbeddedStatement
embeddedStatementTry x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EmbeddedStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "try"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the unchecked variant of hydra.ext.csharp.syntax.EmbeddedStatement
embeddedStatementUnchecked :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.EmbeddedStatement
embeddedStatementUnchecked x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EmbeddedStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "unchecked"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the unsafe variant of hydra.ext.csharp.syntax.EmbeddedStatement
embeddedStatementUnsafe :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.EmbeddedStatement
embeddedStatementUnsafe x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EmbeddedStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "unsafe"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the using variant of hydra.ext.csharp.syntax.EmbeddedStatement
embeddedStatementUsing :: Typed.TypedTerm Syntax.UsingStatement -> Typed.TypedTerm Syntax.EmbeddedStatement
embeddedStatementUsing x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EmbeddedStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "using"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the yield variant of hydra.ext.csharp.syntax.EmbeddedStatement
embeddedStatementYield :: Typed.TypedTerm Syntax.YieldStatement -> Typed.TypedTerm Syntax.EmbeddedStatement
embeddedStatementYield x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EmbeddedStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "yield"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.EnumBase
enumBaseEnumBase :: Typed.TypedName Syntax.EnumBase
enumBaseEnumBase = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.EnumBase")

-- | DSL injection for the name variant of hydra.ext.csharp.syntax.EnumBase
enumBaseName :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.EnumBase
enumBaseName x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumBase"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "name"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the type variant of hydra.ext.csharp.syntax.EnumBase
enumBaseType :: Typed.TypedTerm Syntax.IntegralType -> Typed.TypedTerm Syntax.EnumBase
enumBaseType x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumBase"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "type"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for the hydra.ext.csharp.syntax.EnumBody wrapper
enumBody :: Typed.TypedTerm [Syntax.EnumMemberDeclaration] -> Typed.TypedTerm Syntax.EnumBody
enumBody x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumBody"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.EnumBody
enumBodyEnumBody :: Typed.TypedName Syntax.EnumBody
enumBodyEnumBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.EnumBody")

-- | DSL constructor for hydra.ext.csharp.syntax.EnumDeclaration
enumDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.EnumModifier] -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.EnumBase) -> Typed.TypedTerm (Maybe Syntax.EnumBody) -> Typed.TypedTerm Syntax.EnumDeclaration
enumDeclaration attributes modifiers name base body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm modifiers)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "base"),
          Model.fieldTerm = (Typed.unTypedTerm base)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.EnumDeclaration
enumDeclarationAttributes :: Typed.TypedTerm Syntax.EnumDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes)
enumDeclarationAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the base field of hydra.ext.csharp.syntax.EnumDeclaration
enumDeclarationBase :: Typed.TypedTerm Syntax.EnumDeclaration -> Typed.TypedTerm (Maybe Syntax.EnumBase)
enumDeclarationBase x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"),
        Model.projectionFieldName = (Model.Name "base")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.EnumDeclaration
enumDeclarationBody :: Typed.TypedTerm Syntax.EnumDeclaration -> Typed.TypedTerm (Maybe Syntax.EnumBody)
enumDeclarationBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.EnumDeclaration
enumDeclarationEnumDeclaration :: Typed.TypedName Syntax.EnumDeclaration
enumDeclarationEnumDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration")

-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.EnumDeclaration
enumDeclarationModifiers :: Typed.TypedTerm Syntax.EnumDeclaration -> Typed.TypedTerm [Syntax.EnumModifier]
enumDeclarationModifiers x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"),
        Model.projectionFieldName = (Model.Name "modifiers")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the name field of hydra.ext.csharp.syntax.EnumDeclaration
enumDeclarationName :: Typed.TypedTerm Syntax.EnumDeclaration -> Typed.TypedTerm Syntax.Identifier
enumDeclarationName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.EnumDeclaration
enumDeclarationWithAttributes :: Typed.TypedTerm Syntax.EnumDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.EnumDeclaration
enumDeclarationWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "base"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"),
              Model.projectionFieldName = (Model.Name "base")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the base field of hydra.ext.csharp.syntax.EnumDeclaration
enumDeclarationWithBase :: Typed.TypedTerm Syntax.EnumDeclaration -> Typed.TypedTerm (Maybe Syntax.EnumBase) -> Typed.TypedTerm Syntax.EnumDeclaration
enumDeclarationWithBase original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "base"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the body field of hydra.ext.csharp.syntax.EnumDeclaration
enumDeclarationWithBody :: Typed.TypedTerm Syntax.EnumDeclaration -> Typed.TypedTerm (Maybe Syntax.EnumBody) -> Typed.TypedTerm Syntax.EnumDeclaration
enumDeclarationWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "base"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"),
              Model.projectionFieldName = (Model.Name "base")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.EnumDeclaration
enumDeclarationWithModifiers :: Typed.TypedTerm Syntax.EnumDeclaration -> Typed.TypedTerm [Syntax.EnumModifier] -> Typed.TypedTerm Syntax.EnumDeclaration
enumDeclarationWithModifiers original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "base"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"),
              Model.projectionFieldName = (Model.Name "base")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.csharp.syntax.EnumDeclaration
enumDeclarationWithName :: Typed.TypedTerm Syntax.EnumDeclaration -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.EnumDeclaration
enumDeclarationWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "base"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"),
              Model.projectionFieldName = (Model.Name "base")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.EnumMemberDeclaration
enumMemberDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.ConstantExpression) -> Typed.TypedTerm Syntax.EnumMemberDeclaration
enumMemberDeclaration attributes name value =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumMemberDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Typed.unTypedTerm value)}]}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.EnumMemberDeclaration
enumMemberDeclarationAttributes :: Typed.TypedTerm Syntax.EnumMemberDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes)
enumMemberDeclarationAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumMemberDeclaration"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.EnumMemberDeclaration
enumMemberDeclarationEnumMemberDeclaration :: Typed.TypedName Syntax.EnumMemberDeclaration
enumMemberDeclarationEnumMemberDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.EnumMemberDeclaration")

-- | DSL accessor for the name field of hydra.ext.csharp.syntax.EnumMemberDeclaration
enumMemberDeclarationName :: Typed.TypedTerm Syntax.EnumMemberDeclaration -> Typed.TypedTerm Syntax.Identifier
enumMemberDeclarationName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumMemberDeclaration"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the value field of hydra.ext.csharp.syntax.EnumMemberDeclaration
enumMemberDeclarationValue :: Typed.TypedTerm Syntax.EnumMemberDeclaration -> Typed.TypedTerm (Maybe Syntax.ConstantExpression)
enumMemberDeclarationValue x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumMemberDeclaration"),
        Model.projectionFieldName = (Model.Name "value")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.EnumMemberDeclaration
enumMemberDeclarationWithAttributes :: Typed.TypedTerm Syntax.EnumMemberDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.EnumMemberDeclaration
enumMemberDeclarationWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumMemberDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumMemberDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumMemberDeclaration"),
              Model.projectionFieldName = (Model.Name "value")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.csharp.syntax.EnumMemberDeclaration
enumMemberDeclarationWithName :: Typed.TypedTerm Syntax.EnumMemberDeclaration -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.EnumMemberDeclaration
enumMemberDeclarationWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumMemberDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumMemberDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumMemberDeclaration"),
              Model.projectionFieldName = (Model.Name "value")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the value field of hydra.ext.csharp.syntax.EnumMemberDeclaration
enumMemberDeclarationWithValue :: Typed.TypedTerm Syntax.EnumMemberDeclaration -> Typed.TypedTerm (Maybe Syntax.ConstantExpression) -> Typed.TypedTerm Syntax.EnumMemberDeclaration
enumMemberDeclarationWithValue original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumMemberDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumMemberDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumMemberDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.EnumModifier
enumModifierEnumModifier :: Typed.TypedName Syntax.EnumModifier
enumModifierEnumModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.EnumModifier")

-- | DSL injection for the internal variant of hydra.ext.csharp.syntax.EnumModifier
enumModifierInternal :: Typed.TypedTerm Syntax.EnumModifier
enumModifierInternal =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "internal"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the new variant of hydra.ext.csharp.syntax.EnumModifier
enumModifierNew :: Typed.TypedTerm Syntax.EnumModifier
enumModifierNew =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "new"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the private variant of hydra.ext.csharp.syntax.EnumModifier
enumModifierPrivate :: Typed.TypedTerm Syntax.EnumModifier
enumModifierPrivate =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "private"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the protected variant of hydra.ext.csharp.syntax.EnumModifier
enumModifierProtected :: Typed.TypedTerm Syntax.EnumModifier
enumModifierProtected =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "protected"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the public variant of hydra.ext.csharp.syntax.EnumModifier
enumModifierPublic :: Typed.TypedTerm Syntax.EnumModifier
enumModifierPublic =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "public"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL constructor for the hydra.ext.csharp.syntax.EnumType wrapper
enumType :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.EnumType
enumType x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.EnumType"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.EnumType
enumTypeEnumType :: Typed.TypedName Syntax.EnumType
enumTypeEnumType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.EnumType")

-- | DSL injection for the binary variant of hydra.ext.csharp.syntax.EqualityExpression
equalityExpressionBinary :: Typed.TypedTerm Syntax.BinaryEqualityExpression -> Typed.TypedTerm Syntax.EqualityExpression
equalityExpressionBinary x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EqualityExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "binary"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.EqualityExpression
equalityExpressionEqualityExpression :: Typed.TypedName Syntax.EqualityExpression
equalityExpressionEqualityExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.EqualityExpression")

-- | DSL injection for the simple variant of hydra.ext.csharp.syntax.EqualityExpression
equalityExpressionSimple :: Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.EqualityExpression
equalityExpressionSimple x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EqualityExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "simple"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the equal variant of hydra.ext.csharp.syntax.EqualityOperator
equalityOperatorEqual :: Typed.TypedTerm Syntax.EqualityOperator
equalityOperatorEqual =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EqualityOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "equal"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.csharp.syntax.EqualityOperator
equalityOperatorEqualityOperator :: Typed.TypedName Syntax.EqualityOperator
equalityOperatorEqualityOperator = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.EqualityOperator")

-- | DSL injection for the notEqual variant of hydra.ext.csharp.syntax.EqualityOperator
equalityOperatorNotEqual :: Typed.TypedTerm Syntax.EqualityOperator
equalityOperatorNotEqual =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EqualityOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "notEqual"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the add variant of hydra.ext.csharp.syntax.EventAccessorDeclarations
eventAccessorDeclarationsAdd :: Typed.TypedTerm Syntax.AddRemoveAccessorDeclaration -> Typed.TypedTerm Syntax.EventAccessorDeclarations
eventAccessorDeclarationsAdd x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventAccessorDeclarations"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "add"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.EventAccessorDeclarations
eventAccessorDeclarationsEventAccessorDeclarations :: Typed.TypedName Syntax.EventAccessorDeclarations
eventAccessorDeclarationsEventAccessorDeclarations =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.EventAccessorDeclarations")

-- | DSL injection for the remove variant of hydra.ext.csharp.syntax.EventAccessorDeclarations
eventAccessorDeclarationsRemove :: Typed.TypedTerm Syntax.AddRemoveAccessorDeclaration -> Typed.TypedTerm Syntax.EventAccessorDeclarations
eventAccessorDeclarationsRemove x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventAccessorDeclarations"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "remove"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the accessors variant of hydra.ext.csharp.syntax.EventDeclaration
eventDeclarationAccessors :: Typed.TypedTerm Syntax.AccessorsEventDeclaration -> Typed.TypedTerm Syntax.EventDeclaration
eventDeclarationAccessors x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "accessors"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.EventDeclaration
eventDeclarationEventDeclaration :: Typed.TypedName Syntax.EventDeclaration
eventDeclarationEventDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.EventDeclaration")

-- | DSL injection for the standard variant of hydra.ext.csharp.syntax.EventDeclaration
eventDeclarationStandard :: Typed.TypedTerm Syntax.StandardEventDeclaration -> Typed.TypedTerm Syntax.EventDeclaration
eventDeclarationStandard x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "standard"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the abstract variant of hydra.ext.csharp.syntax.EventModifier
eventModifierAbstract :: Typed.TypedTerm Syntax.EventModifier
eventModifierAbstract =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "abstract"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.csharp.syntax.EventModifier
eventModifierEventModifier :: Typed.TypedName Syntax.EventModifier
eventModifierEventModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.EventModifier")

-- | DSL injection for the extern variant of hydra.ext.csharp.syntax.EventModifier
eventModifierExtern :: Typed.TypedTerm Syntax.EventModifier
eventModifierExtern =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "extern"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the internal variant of hydra.ext.csharp.syntax.EventModifier
eventModifierInternal :: Typed.TypedTerm Syntax.EventModifier
eventModifierInternal =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "internal"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the new variant of hydra.ext.csharp.syntax.EventModifier
eventModifierNew :: Typed.TypedTerm Syntax.EventModifier
eventModifierNew =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "new"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the override variant of hydra.ext.csharp.syntax.EventModifier
eventModifierOverride :: Typed.TypedTerm Syntax.EventModifier
eventModifierOverride =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "override"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the private variant of hydra.ext.csharp.syntax.EventModifier
eventModifierPrivate :: Typed.TypedTerm Syntax.EventModifier
eventModifierPrivate =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "private"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the protected variant of hydra.ext.csharp.syntax.EventModifier
eventModifierProtected :: Typed.TypedTerm Syntax.EventModifier
eventModifierProtected =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "protected"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the public variant of hydra.ext.csharp.syntax.EventModifier
eventModifierPublic :: Typed.TypedTerm Syntax.EventModifier
eventModifierPublic =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "public"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the sealed variant of hydra.ext.csharp.syntax.EventModifier
eventModifierSealed :: Typed.TypedTerm Syntax.EventModifier
eventModifierSealed =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "sealed"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the static variant of hydra.ext.csharp.syntax.EventModifier
eventModifierStatic :: Typed.TypedTerm Syntax.EventModifier
eventModifierStatic =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "static"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the unsafe variant of hydra.ext.csharp.syntax.EventModifier
eventModifierUnsafe :: Typed.TypedTerm Syntax.EventModifier
eventModifierUnsafe =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "unsafe"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the virtual variant of hydra.ext.csharp.syntax.EventModifier
eventModifierVirtual :: Typed.TypedTerm Syntax.EventModifier
eventModifierVirtual =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.EventModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "virtual"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL constructor for hydra.ext.csharp.syntax.ExceptionSpecifier
exceptionSpecifier :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.ExceptionSpecifier
exceptionSpecifier type_ identifier =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ExceptionSpecifier"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm identifier)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.ExceptionSpecifier
exceptionSpecifierExceptionSpecifier :: Typed.TypedName Syntax.ExceptionSpecifier
exceptionSpecifierExceptionSpecifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ExceptionSpecifier")

-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.ExceptionSpecifier
exceptionSpecifierIdentifier :: Typed.TypedTerm Syntax.ExceptionSpecifier -> Typed.TypedTerm (Maybe Syntax.Identifier)
exceptionSpecifierIdentifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExceptionSpecifier"),
        Model.projectionFieldName = (Model.Name "identifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.ExceptionSpecifier
exceptionSpecifierType :: Typed.TypedTerm Syntax.ExceptionSpecifier -> Typed.TypedTerm Syntax.Type
exceptionSpecifierType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExceptionSpecifier"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.ExceptionSpecifier
exceptionSpecifierWithIdentifier :: Typed.TypedTerm Syntax.ExceptionSpecifier -> Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.ExceptionSpecifier
exceptionSpecifierWithIdentifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ExceptionSpecifier"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExceptionSpecifier"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.ExceptionSpecifier
exceptionSpecifierWithType :: Typed.TypedTerm Syntax.ExceptionSpecifier -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ExceptionSpecifier
exceptionSpecifierWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ExceptionSpecifier"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExceptionSpecifier"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the binary variant of hydra.ext.csharp.syntax.ExclusiveOrExpression
exclusiveOrExpressionBinary :: Typed.TypedTerm Syntax.BinaryExclusiveOrExpression -> Typed.TypedTerm Syntax.ExclusiveOrExpression
exclusiveOrExpressionBinary x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExclusiveOrExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "binary"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.ExclusiveOrExpression
exclusiveOrExpressionExclusiveOrExpression :: Typed.TypedName Syntax.ExclusiveOrExpression
exclusiveOrExpressionExclusiveOrExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ExclusiveOrExpression")

-- | DSL injection for the simple variant of hydra.ext.csharp.syntax.ExclusiveOrExpression
exclusiveOrExpressionSimple :: Typed.TypedTerm Syntax.AndExpression -> Typed.TypedTerm Syntax.ExclusiveOrExpression
exclusiveOrExpressionSimple x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExclusiveOrExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "simple"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter
explicitAnonymousFunctionParameter :: Typed.TypedTerm (Maybe Syntax.AnonymousFunctionParameterModifier) -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ExplicitAnonymousFunctionParameter
explicitAnonymousFunctionParameter modifier type_ identifier =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "modifier"),
          Model.fieldTerm = (Typed.unTypedTerm modifier)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm identifier)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter
explicitAnonymousFunctionParameterExplicitAnonymousFunctionParameter :: Typed.TypedName Syntax.ExplicitAnonymousFunctionParameter
explicitAnonymousFunctionParameterExplicitAnonymousFunctionParameter =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter")

-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter
explicitAnonymousFunctionParameterIdentifier :: Typed.TypedTerm Syntax.ExplicitAnonymousFunctionParameter -> Typed.TypedTerm Syntax.Identifier
explicitAnonymousFunctionParameterIdentifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter"),
        Model.projectionFieldName = (Model.Name "identifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the modifier field of hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter
explicitAnonymousFunctionParameterModifier :: Typed.TypedTerm Syntax.ExplicitAnonymousFunctionParameter -> Typed.TypedTerm (Maybe Syntax.AnonymousFunctionParameterModifier)
explicitAnonymousFunctionParameterModifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter"),
        Model.projectionFieldName = (Model.Name "modifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter
explicitAnonymousFunctionParameterType :: Typed.TypedTerm Syntax.ExplicitAnonymousFunctionParameter -> Typed.TypedTerm Syntax.Type
explicitAnonymousFunctionParameterType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter
explicitAnonymousFunctionParameterWithIdentifier :: Typed.TypedTerm Syntax.ExplicitAnonymousFunctionParameter -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ExplicitAnonymousFunctionParameter
explicitAnonymousFunctionParameterWithIdentifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "modifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter"),
              Model.projectionFieldName = (Model.Name "modifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the modifier field of hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter
explicitAnonymousFunctionParameterWithModifier :: Typed.TypedTerm Syntax.ExplicitAnonymousFunctionParameter -> Typed.TypedTerm (Maybe Syntax.AnonymousFunctionParameterModifier) -> Typed.TypedTerm Syntax.ExplicitAnonymousFunctionParameter
explicitAnonymousFunctionParameterWithModifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "modifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter
explicitAnonymousFunctionParameterWithType :: Typed.TypedTerm Syntax.ExplicitAnonymousFunctionParameter -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ExplicitAnonymousFunctionParameter
explicitAnonymousFunctionParameterWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "modifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter"),
              Model.projectionFieldName = (Model.Name "modifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitAnonymousFunctionParameter"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration
explicitlyTypedLocalVariableDeclaration :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm [Syntax.ExplicitlyTypedLocalVariableDeclarator] -> Typed.TypedTerm Syntax.ExplicitlyTypedLocalVariableDeclaration
explicitlyTypedLocalVariableDeclaration type_ declarators =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Typed.unTypedTerm declarators)}]}))

-- | DSL accessor for the declarators field of hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration
explicitlyTypedLocalVariableDeclarationDeclarators :: Typed.TypedTerm Syntax.ExplicitlyTypedLocalVariableDeclaration -> Typed.TypedTerm [Syntax.ExplicitlyTypedLocalVariableDeclarator]
explicitlyTypedLocalVariableDeclarationDeclarators x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration"),
        Model.projectionFieldName = (Model.Name "declarators")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration
explicitlyTypedLocalVariableDeclarationExplicitlyTypedLocalVariableDeclaration :: Typed.TypedName Syntax.ExplicitlyTypedLocalVariableDeclaration
explicitlyTypedLocalVariableDeclarationExplicitlyTypedLocalVariableDeclaration =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration")

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration
explicitlyTypedLocalVariableDeclarationType :: Typed.TypedTerm Syntax.ExplicitlyTypedLocalVariableDeclaration -> Typed.TypedTerm Syntax.Type
explicitlyTypedLocalVariableDeclarationType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the declarators field of hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration
explicitlyTypedLocalVariableDeclarationWithDeclarators :: Typed.TypedTerm Syntax.ExplicitlyTypedLocalVariableDeclaration -> Typed.TypedTerm [Syntax.ExplicitlyTypedLocalVariableDeclarator] -> Typed.TypedTerm Syntax.ExplicitlyTypedLocalVariableDeclaration
explicitlyTypedLocalVariableDeclarationWithDeclarators original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration
explicitlyTypedLocalVariableDeclarationWithType :: Typed.TypedTerm Syntax.ExplicitlyTypedLocalVariableDeclaration -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ExplicitlyTypedLocalVariableDeclaration
explicitlyTypedLocalVariableDeclarationWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration"),
              Model.projectionFieldName = (Model.Name "declarators")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator
explicitlyTypedLocalVariableDeclarator :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.LocalVariableInitializer) -> Typed.TypedTerm Syntax.ExplicitlyTypedLocalVariableDeclarator
explicitlyTypedLocalVariableDeclarator identifier initializer =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm identifier)},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Typed.unTypedTerm initializer)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator
explicitlyTypedLocalVariableDeclaratorExplicitlyTypedLocalVariableDeclarator :: Typed.TypedName Syntax.ExplicitlyTypedLocalVariableDeclarator
explicitlyTypedLocalVariableDeclaratorExplicitlyTypedLocalVariableDeclarator =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator")

-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator
explicitlyTypedLocalVariableDeclaratorIdentifier :: Typed.TypedTerm Syntax.ExplicitlyTypedLocalVariableDeclarator -> Typed.TypedTerm Syntax.Identifier
explicitlyTypedLocalVariableDeclaratorIdentifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator"),
        Model.projectionFieldName = (Model.Name "identifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the initializer field of hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator
explicitlyTypedLocalVariableDeclaratorInitializer :: Typed.TypedTerm Syntax.ExplicitlyTypedLocalVariableDeclarator -> Typed.TypedTerm (Maybe Syntax.LocalVariableInitializer)
explicitlyTypedLocalVariableDeclaratorInitializer x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator"),
        Model.projectionFieldName = (Model.Name "initializer")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator
explicitlyTypedLocalVariableDeclaratorWithIdentifier :: Typed.TypedTerm Syntax.ExplicitlyTypedLocalVariableDeclarator -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ExplicitlyTypedLocalVariableDeclarator
explicitlyTypedLocalVariableDeclaratorWithIdentifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator"),
              Model.projectionFieldName = (Model.Name "initializer")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the initializer field of hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator
explicitlyTypedLocalVariableDeclaratorWithInitializer :: Typed.TypedTerm Syntax.ExplicitlyTypedLocalVariableDeclarator -> Typed.TypedTerm (Maybe Syntax.LocalVariableInitializer) -> Typed.TypedTerm Syntax.ExplicitlyTypedLocalVariableDeclarator
explicitlyTypedLocalVariableDeclaratorWithInitializer original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the assignment variant of hydra.ext.csharp.syntax.Expression
expressionAssignment :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm Syntax.Expression
expressionAssignment x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Expression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "assignment"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.Expression
expressionExpression :: Typed.TypedName Syntax.Expression
expressionExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.Expression")

-- | DSL constructor for the hydra.ext.csharp.syntax.ExpressionList wrapper
expressionList :: Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.ExpressionList
expressionList x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.ExpressionList"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.ExpressionList
expressionListExpressionList :: Typed.TypedName Syntax.ExpressionList
expressionListExpressionList = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ExpressionList")

-- | DSL injection for the nonAssignment variant of hydra.ext.csharp.syntax.Expression
expressionNonAssignment :: Typed.TypedTerm Syntax.NonAssignmentExpression -> Typed.TypedTerm Syntax.Expression
expressionNonAssignment x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Expression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "nonAssignment"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for the hydra.ext.csharp.syntax.ExternAliasDirective wrapper
externAliasDirective :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ExternAliasDirective
externAliasDirective x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.ExternAliasDirective"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.ExternAliasDirective
externAliasDirectiveExternAliasDirective :: Typed.TypedName Syntax.ExternAliasDirective
externAliasDirectiveExternAliasDirective = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ExternAliasDirective")

-- | DSL constructor for hydra.ext.csharp.syntax.FieldDeclaration
fieldDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.FieldModifier] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm [Syntax.VariableDeclarator] -> Typed.TypedTerm Syntax.FieldDeclaration
fieldDeclaration attributes modifiers type_ declarators =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm modifiers)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Typed.unTypedTerm declarators)}]}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.FieldDeclaration
fieldDeclarationAttributes :: Typed.TypedTerm Syntax.FieldDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes)
fieldDeclarationAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the declarators field of hydra.ext.csharp.syntax.FieldDeclaration
fieldDeclarationDeclarators :: Typed.TypedTerm Syntax.FieldDeclaration -> Typed.TypedTerm [Syntax.VariableDeclarator]
fieldDeclarationDeclarators x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"),
        Model.projectionFieldName = (Model.Name "declarators")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.FieldDeclaration
fieldDeclarationFieldDeclaration :: Typed.TypedName Syntax.FieldDeclaration
fieldDeclarationFieldDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration")

-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.FieldDeclaration
fieldDeclarationModifiers :: Typed.TypedTerm Syntax.FieldDeclaration -> Typed.TypedTerm [Syntax.FieldModifier]
fieldDeclarationModifiers x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"),
        Model.projectionFieldName = (Model.Name "modifiers")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.FieldDeclaration
fieldDeclarationType :: Typed.TypedTerm Syntax.FieldDeclaration -> Typed.TypedTerm Syntax.Type
fieldDeclarationType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.FieldDeclaration
fieldDeclarationWithAttributes :: Typed.TypedTerm Syntax.FieldDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.FieldDeclaration
fieldDeclarationWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"),
              Model.projectionFieldName = (Model.Name "declarators")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the declarators field of hydra.ext.csharp.syntax.FieldDeclaration
fieldDeclarationWithDeclarators :: Typed.TypedTerm Syntax.FieldDeclaration -> Typed.TypedTerm [Syntax.VariableDeclarator] -> Typed.TypedTerm Syntax.FieldDeclaration
fieldDeclarationWithDeclarators original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.FieldDeclaration
fieldDeclarationWithModifiers :: Typed.TypedTerm Syntax.FieldDeclaration -> Typed.TypedTerm [Syntax.FieldModifier] -> Typed.TypedTerm Syntax.FieldDeclaration
fieldDeclarationWithModifiers original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"),
              Model.projectionFieldName = (Model.Name "declarators")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.FieldDeclaration
fieldDeclarationWithType :: Typed.TypedTerm Syntax.FieldDeclaration -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.FieldDeclaration
fieldDeclarationWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldDeclaration"),
              Model.projectionFieldName = (Model.Name "declarators")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL name token for hydra.ext.csharp.syntax.FieldModifier
fieldModifierFieldModifier :: Typed.TypedName Syntax.FieldModifier
fieldModifierFieldModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.FieldModifier")

-- | DSL injection for the internal variant of hydra.ext.csharp.syntax.FieldModifier
fieldModifierInternal :: Typed.TypedTerm Syntax.FieldModifier
fieldModifierInternal =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "internal"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the new variant of hydra.ext.csharp.syntax.FieldModifier
fieldModifierNew :: Typed.TypedTerm Syntax.FieldModifier
fieldModifierNew =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "new"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the private variant of hydra.ext.csharp.syntax.FieldModifier
fieldModifierPrivate :: Typed.TypedTerm Syntax.FieldModifier
fieldModifierPrivate =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "private"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the protected variant of hydra.ext.csharp.syntax.FieldModifier
fieldModifierProtected :: Typed.TypedTerm Syntax.FieldModifier
fieldModifierProtected =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "protected"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the public variant of hydra.ext.csharp.syntax.FieldModifier
fieldModifierPublic :: Typed.TypedTerm Syntax.FieldModifier
fieldModifierPublic =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "public"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the readonly variant of hydra.ext.csharp.syntax.FieldModifier
fieldModifierReadonly :: Typed.TypedTerm Syntax.FieldModifier
fieldModifierReadonly =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "readonly"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the static variant of hydra.ext.csharp.syntax.FieldModifier
fieldModifierStatic :: Typed.TypedTerm Syntax.FieldModifier
fieldModifierStatic =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "static"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the unsafe variant of hydra.ext.csharp.syntax.FieldModifier
fieldModifierUnsafe :: Typed.TypedTerm Syntax.FieldModifier
fieldModifierUnsafe =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "unsafe"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the volatile variant of hydra.ext.csharp.syntax.FieldModifier
fieldModifierVolatile :: Typed.TypedTerm Syntax.FieldModifier
fieldModifierVolatile =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FieldModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "volatile"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the block variant of hydra.ext.csharp.syntax.FinalizerBody
finalizerBodyBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.FinalizerBody
finalizerBodyBlock x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "block"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the empty variant of hydra.ext.csharp.syntax.FinalizerBody
finalizerBodyEmpty :: Typed.TypedTerm Syntax.FinalizerBody
finalizerBodyEmpty =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "empty"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.FinalizerBody
finalizerBodyExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.FinalizerBody
finalizerBodyExpression x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "expression"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.FinalizerBody
finalizerBodyFinalizerBody :: Typed.TypedName Syntax.FinalizerBody
finalizerBodyFinalizerBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.FinalizerBody")

-- | DSL constructor for hydra.ext.csharp.syntax.FinalizerDeclaration
finalizerDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.FinalizerBody -> Typed.TypedTerm Syntax.FinalizerDeclaration
finalizerDeclaration attributes extern unsafe name body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "extern"),
          Model.fieldTerm = (Typed.unTypedTerm extern)},
        Model.Field {
          Model.fieldName = (Model.Name "unsafe"),
          Model.fieldTerm = (Typed.unTypedTerm unsafe)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.FinalizerDeclaration
finalizerDeclarationAttributes :: Typed.TypedTerm Syntax.FinalizerDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes)
finalizerDeclarationAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.FinalizerDeclaration
finalizerDeclarationBody :: Typed.TypedTerm Syntax.FinalizerDeclaration -> Typed.TypedTerm Syntax.FinalizerBody
finalizerDeclarationBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the extern field of hydra.ext.csharp.syntax.FinalizerDeclaration
finalizerDeclarationExtern :: Typed.TypedTerm Syntax.FinalizerDeclaration -> Typed.TypedTerm Bool
finalizerDeclarationExtern x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"),
        Model.projectionFieldName = (Model.Name "extern")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.FinalizerDeclaration
finalizerDeclarationFinalizerDeclaration :: Typed.TypedName Syntax.FinalizerDeclaration
finalizerDeclarationFinalizerDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration")

-- | DSL accessor for the name field of hydra.ext.csharp.syntax.FinalizerDeclaration
finalizerDeclarationName :: Typed.TypedTerm Syntax.FinalizerDeclaration -> Typed.TypedTerm Syntax.Identifier
finalizerDeclarationName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the unsafe field of hydra.ext.csharp.syntax.FinalizerDeclaration
finalizerDeclarationUnsafe :: Typed.TypedTerm Syntax.FinalizerDeclaration -> Typed.TypedTerm Bool
finalizerDeclarationUnsafe x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"),
        Model.projectionFieldName = (Model.Name "unsafe")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.FinalizerDeclaration
finalizerDeclarationWithAttributes :: Typed.TypedTerm Syntax.FinalizerDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.FinalizerDeclaration
finalizerDeclarationWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "extern"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"),
              Model.projectionFieldName = (Model.Name "extern")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "unsafe"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"),
              Model.projectionFieldName = (Model.Name "unsafe")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the body field of hydra.ext.csharp.syntax.FinalizerDeclaration
finalizerDeclarationWithBody :: Typed.TypedTerm Syntax.FinalizerDeclaration -> Typed.TypedTerm Syntax.FinalizerBody -> Typed.TypedTerm Syntax.FinalizerDeclaration
finalizerDeclarationWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "extern"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"),
              Model.projectionFieldName = (Model.Name "extern")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "unsafe"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"),
              Model.projectionFieldName = (Model.Name "unsafe")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the extern field of hydra.ext.csharp.syntax.FinalizerDeclaration
finalizerDeclarationWithExtern :: Typed.TypedTerm Syntax.FinalizerDeclaration -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.FinalizerDeclaration
finalizerDeclarationWithExtern original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "extern"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "unsafe"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"),
              Model.projectionFieldName = (Model.Name "unsafe")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.csharp.syntax.FinalizerDeclaration
finalizerDeclarationWithName :: Typed.TypedTerm Syntax.FinalizerDeclaration -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.FinalizerDeclaration
finalizerDeclarationWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "extern"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"),
              Model.projectionFieldName = (Model.Name "extern")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "unsafe"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"),
              Model.projectionFieldName = (Model.Name "unsafe")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the unsafe field of hydra.ext.csharp.syntax.FinalizerDeclaration
finalizerDeclarationWithUnsafe :: Typed.TypedTerm Syntax.FinalizerDeclaration -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.FinalizerDeclaration
finalizerDeclarationWithUnsafe original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "extern"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"),
              Model.projectionFieldName = (Model.Name "extern")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "unsafe"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FinalizerDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.FixedParameter
fixedParameter :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm (Maybe Syntax.ParameterModifier) -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.FixedParameter
fixedParameter attributes modifier type_ identifier defaultArgument =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "modifier"),
          Model.fieldTerm = (Typed.unTypedTerm modifier)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm identifier)},
        Model.Field {
          Model.fieldName = (Model.Name "defaultArgument"),
          Model.fieldTerm = (Typed.unTypedTerm defaultArgument)}]}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.FixedParameter
fixedParameterAttributes :: Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm (Maybe Syntax.Attributes)
fixedParameterAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the defaultArgument field of hydra.ext.csharp.syntax.FixedParameter
fixedParameterDefaultArgument :: Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm (Maybe Syntax.Expression)
fixedParameterDefaultArgument x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"),
        Model.projectionFieldName = (Model.Name "defaultArgument")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.FixedParameter
fixedParameterFixedParameter :: Typed.TypedName Syntax.FixedParameter
fixedParameterFixedParameter = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.FixedParameter")

-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.FixedParameter
fixedParameterIdentifier :: Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm Syntax.Identifier
fixedParameterIdentifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"),
        Model.projectionFieldName = (Model.Name "identifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the modifier field of hydra.ext.csharp.syntax.FixedParameter
fixedParameterModifier :: Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm (Maybe Syntax.ParameterModifier)
fixedParameterModifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"),
        Model.projectionFieldName = (Model.Name "modifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.FixedParameter
fixedParameterType :: Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm Syntax.Type
fixedParameterType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.FixedParameter
fixedParameterWithAttributes :: Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.FixedParameter
fixedParameterWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "modifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"),
              Model.projectionFieldName = (Model.Name "modifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "defaultArgument"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"),
              Model.projectionFieldName = (Model.Name "defaultArgument")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the defaultArgument field of hydra.ext.csharp.syntax.FixedParameter
fixedParameterWithDefaultArgument :: Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.FixedParameter
fixedParameterWithDefaultArgument original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"),
              Model.projectionFieldName = (Model.Name "modifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "defaultArgument"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.FixedParameter
fixedParameterWithIdentifier :: Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.FixedParameter
fixedParameterWithIdentifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"),
              Model.projectionFieldName = (Model.Name "modifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "defaultArgument"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"),
              Model.projectionFieldName = (Model.Name "defaultArgument")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the modifier field of hydra.ext.csharp.syntax.FixedParameter
fixedParameterWithModifier :: Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm (Maybe Syntax.ParameterModifier) -> Typed.TypedTerm Syntax.FixedParameter
fixedParameterWithModifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "defaultArgument"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"),
              Model.projectionFieldName = (Model.Name "defaultArgument")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.FixedParameter
fixedParameterWithType :: Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.FixedParameter
fixedParameterWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"),
              Model.projectionFieldName = (Model.Name "modifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "defaultArgument"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedParameter"),
              Model.projectionFieldName = (Model.Name "defaultArgument")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.FixedPointerDeclarator
fixedPointerDeclaratorExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.FixedPointerDeclarator
fixedPointerDeclaratorExpression x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedPointerDeclarator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "expression"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.FixedPointerDeclarator
fixedPointerDeclaratorFixedPointerDeclarator :: Typed.TypedName Syntax.FixedPointerDeclarator
fixedPointerDeclaratorFixedPointerDeclarator =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.FixedPointerDeclarator")

-- | DSL injection for the reference variant of hydra.ext.csharp.syntax.FixedPointerDeclarator
fixedPointerDeclaratorReference :: Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.FixedPointerDeclarator
fixedPointerDeclaratorReference x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedPointerDeclarator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "reference"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.csharp.syntax.FixedSizeBufferDeclaration
fixedSizeBufferDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.FixedSizeBufferModifier] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm [Syntax.FixedSizeBufferDeclarator] -> Typed.TypedTerm Syntax.FixedSizeBufferDeclaration
fixedSizeBufferDeclaration attributes modifiers elementType declarators =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm modifiers)},
        Model.Field {
          Model.fieldName = (Model.Name "elementType"),
          Model.fieldTerm = (Typed.unTypedTerm elementType)},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Typed.unTypedTerm declarators)}]}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.FixedSizeBufferDeclaration
fixedSizeBufferDeclarationAttributes :: Typed.TypedTerm Syntax.FixedSizeBufferDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes)
fixedSizeBufferDeclarationAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the declarators field of hydra.ext.csharp.syntax.FixedSizeBufferDeclaration
fixedSizeBufferDeclarationDeclarators :: Typed.TypedTerm Syntax.FixedSizeBufferDeclaration -> Typed.TypedTerm [Syntax.FixedSizeBufferDeclarator]
fixedSizeBufferDeclarationDeclarators x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"),
        Model.projectionFieldName = (Model.Name "declarators")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the elementType field of hydra.ext.csharp.syntax.FixedSizeBufferDeclaration
fixedSizeBufferDeclarationElementType :: Typed.TypedTerm Syntax.FixedSizeBufferDeclaration -> Typed.TypedTerm Syntax.Type
fixedSizeBufferDeclarationElementType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"),
        Model.projectionFieldName = (Model.Name "elementType")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.FixedSizeBufferDeclaration
fixedSizeBufferDeclarationFixedSizeBufferDeclaration :: Typed.TypedName Syntax.FixedSizeBufferDeclaration
fixedSizeBufferDeclarationFixedSizeBufferDeclaration =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration")

-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.FixedSizeBufferDeclaration
fixedSizeBufferDeclarationModifiers :: Typed.TypedTerm Syntax.FixedSizeBufferDeclaration -> Typed.TypedTerm [Syntax.FixedSizeBufferModifier]
fixedSizeBufferDeclarationModifiers x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"),
        Model.projectionFieldName = (Model.Name "modifiers")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.FixedSizeBufferDeclaration
fixedSizeBufferDeclarationWithAttributes :: Typed.TypedTerm Syntax.FixedSizeBufferDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.FixedSizeBufferDeclaration
fixedSizeBufferDeclarationWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "elementType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"),
              Model.projectionFieldName = (Model.Name "elementType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"),
              Model.projectionFieldName = (Model.Name "declarators")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the declarators field of hydra.ext.csharp.syntax.FixedSizeBufferDeclaration
fixedSizeBufferDeclarationWithDeclarators :: Typed.TypedTerm Syntax.FixedSizeBufferDeclaration -> Typed.TypedTerm [Syntax.FixedSizeBufferDeclarator] -> Typed.TypedTerm Syntax.FixedSizeBufferDeclaration
fixedSizeBufferDeclarationWithDeclarators original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "elementType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"),
              Model.projectionFieldName = (Model.Name "elementType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the elementType field of hydra.ext.csharp.syntax.FixedSizeBufferDeclaration
fixedSizeBufferDeclarationWithElementType :: Typed.TypedTerm Syntax.FixedSizeBufferDeclaration -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.FixedSizeBufferDeclaration
fixedSizeBufferDeclarationWithElementType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "elementType"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"),
              Model.projectionFieldName = (Model.Name "declarators")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.FixedSizeBufferDeclaration
fixedSizeBufferDeclarationWithModifiers :: Typed.TypedTerm Syntax.FixedSizeBufferDeclaration -> Typed.TypedTerm [Syntax.FixedSizeBufferModifier] -> Typed.TypedTerm Syntax.FixedSizeBufferDeclaration
fixedSizeBufferDeclarationWithModifiers original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "elementType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"),
              Model.projectionFieldName = (Model.Name "elementType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclaration"),
              Model.projectionFieldName = (Model.Name "declarators")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.FixedSizeBufferDeclarator
fixedSizeBufferDeclarator :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ConstantExpression -> Typed.TypedTerm Syntax.FixedSizeBufferDeclarator
fixedSizeBufferDeclarator name size =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "size"),
          Model.fieldTerm = (Typed.unTypedTerm size)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.FixedSizeBufferDeclarator
fixedSizeBufferDeclaratorFixedSizeBufferDeclarator :: Typed.TypedName Syntax.FixedSizeBufferDeclarator
fixedSizeBufferDeclaratorFixedSizeBufferDeclarator =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclarator")

-- | DSL accessor for the name field of hydra.ext.csharp.syntax.FixedSizeBufferDeclarator
fixedSizeBufferDeclaratorName :: Typed.TypedTerm Syntax.FixedSizeBufferDeclarator -> Typed.TypedTerm Syntax.Identifier
fixedSizeBufferDeclaratorName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclarator"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the size field of hydra.ext.csharp.syntax.FixedSizeBufferDeclarator
fixedSizeBufferDeclaratorSize :: Typed.TypedTerm Syntax.FixedSizeBufferDeclarator -> Typed.TypedTerm Syntax.ConstantExpression
fixedSizeBufferDeclaratorSize x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclarator"),
        Model.projectionFieldName = (Model.Name "size")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the name field of hydra.ext.csharp.syntax.FixedSizeBufferDeclarator
fixedSizeBufferDeclaratorWithName :: Typed.TypedTerm Syntax.FixedSizeBufferDeclarator -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.FixedSizeBufferDeclarator
fixedSizeBufferDeclaratorWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "size"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclarator"),
              Model.projectionFieldName = (Model.Name "size")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the size field of hydra.ext.csharp.syntax.FixedSizeBufferDeclarator
fixedSizeBufferDeclaratorWithSize :: Typed.TypedTerm Syntax.FixedSizeBufferDeclarator -> Typed.TypedTerm Syntax.ConstantExpression -> Typed.TypedTerm Syntax.FixedSizeBufferDeclarator
fixedSizeBufferDeclaratorWithSize original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferDeclarator"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "size"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.FixedSizeBufferModifier
fixedSizeBufferModifierFixedSizeBufferModifier :: Typed.TypedName Syntax.FixedSizeBufferModifier
fixedSizeBufferModifierFixedSizeBufferModifier =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferModifier")

-- | DSL injection for the internal variant of hydra.ext.csharp.syntax.FixedSizeBufferModifier
fixedSizeBufferModifierInternal :: Typed.TypedTerm Syntax.FixedSizeBufferModifier
fixedSizeBufferModifierInternal =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "internal"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the new variant of hydra.ext.csharp.syntax.FixedSizeBufferModifier
fixedSizeBufferModifierNew :: Typed.TypedTerm Syntax.FixedSizeBufferModifier
fixedSizeBufferModifierNew =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "new"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the private variant of hydra.ext.csharp.syntax.FixedSizeBufferModifier
fixedSizeBufferModifierPrivate :: Typed.TypedTerm Syntax.FixedSizeBufferModifier
fixedSizeBufferModifierPrivate =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "private"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the public variant of hydra.ext.csharp.syntax.FixedSizeBufferModifier
fixedSizeBufferModifierPublic :: Typed.TypedTerm Syntax.FixedSizeBufferModifier
fixedSizeBufferModifierPublic =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "public"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the unsafe variant of hydra.ext.csharp.syntax.FixedSizeBufferModifier
fixedSizeBufferModifierUnsafe :: Typed.TypedTerm Syntax.FixedSizeBufferModifier
fixedSizeBufferModifierUnsafe =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedSizeBufferModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "unsafe"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL constructor for hydra.ext.csharp.syntax.FixedStatement
fixedStatement :: Typed.TypedTerm Syntax.PointerType -> Typed.TypedTerm [Syntax.FixedPointerDeclarator] -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.FixedStatement
fixedStatement pointerType declarators statement =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "pointerType"),
          Model.fieldTerm = (Typed.unTypedTerm pointerType)},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Typed.unTypedTerm declarators)},
        Model.Field {
          Model.fieldName = (Model.Name "statement"),
          Model.fieldTerm = (Typed.unTypedTerm statement)}]}))

-- | DSL accessor for the declarators field of hydra.ext.csharp.syntax.FixedStatement
fixedStatementDeclarators :: Typed.TypedTerm Syntax.FixedStatement -> Typed.TypedTerm [Syntax.FixedPointerDeclarator]
fixedStatementDeclarators x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedStatement"),
        Model.projectionFieldName = (Model.Name "declarators")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.FixedStatement
fixedStatementFixedStatement :: Typed.TypedName Syntax.FixedStatement
fixedStatementFixedStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.FixedStatement")

-- | DSL accessor for the pointerType field of hydra.ext.csharp.syntax.FixedStatement
fixedStatementPointerType :: Typed.TypedTerm Syntax.FixedStatement -> Typed.TypedTerm Syntax.PointerType
fixedStatementPointerType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedStatement"),
        Model.projectionFieldName = (Model.Name "pointerType")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the statement field of hydra.ext.csharp.syntax.FixedStatement
fixedStatementStatement :: Typed.TypedTerm Syntax.FixedStatement -> Typed.TypedTerm Syntax.EmbeddedStatement
fixedStatementStatement x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedStatement"),
        Model.projectionFieldName = (Model.Name "statement")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the declarators field of hydra.ext.csharp.syntax.FixedStatement
fixedStatementWithDeclarators :: Typed.TypedTerm Syntax.FixedStatement -> Typed.TypedTerm [Syntax.FixedPointerDeclarator] -> Typed.TypedTerm Syntax.FixedStatement
fixedStatementWithDeclarators original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "pointerType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedStatement"),
              Model.projectionFieldName = (Model.Name "pointerType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "statement"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedStatement"),
              Model.projectionFieldName = (Model.Name "statement")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the pointerType field of hydra.ext.csharp.syntax.FixedStatement
fixedStatementWithPointerType :: Typed.TypedTerm Syntax.FixedStatement -> Typed.TypedTerm Syntax.PointerType -> Typed.TypedTerm Syntax.FixedStatement
fixedStatementWithPointerType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "pointerType"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedStatement"),
              Model.projectionFieldName = (Model.Name "declarators")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "statement"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedStatement"),
              Model.projectionFieldName = (Model.Name "statement")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the statement field of hydra.ext.csharp.syntax.FixedStatement
fixedStatementWithStatement :: Typed.TypedTerm Syntax.FixedStatement -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.FixedStatement
fixedStatementWithStatement original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "pointerType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedStatement"),
              Model.projectionFieldName = (Model.Name "pointerType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FixedStatement"),
              Model.projectionFieldName = (Model.Name "declarators")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "statement"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the double variant of hydra.ext.csharp.syntax.FloatingPointType
floatingPointTypeDouble :: Typed.TypedTerm Syntax.FloatingPointType
floatingPointTypeDouble =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FloatingPointType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "double"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the float variant of hydra.ext.csharp.syntax.FloatingPointType
floatingPointTypeFloat :: Typed.TypedTerm Syntax.FloatingPointType
floatingPointTypeFloat =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FloatingPointType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "float"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.csharp.syntax.FloatingPointType
floatingPointTypeFloatingPointType :: Typed.TypedName Syntax.FloatingPointType
floatingPointTypeFloatingPointType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.FloatingPointType")

-- | DSL name token for hydra.ext.csharp.syntax.ForInitializer
forInitializerForInitializer :: Typed.TypedName Syntax.ForInitializer
forInitializerForInitializer = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ForInitializer")

-- | DSL injection for the statements variant of hydra.ext.csharp.syntax.ForInitializer
forInitializerStatements :: Typed.TypedTerm Syntax.StatementExpressionList -> Typed.TypedTerm Syntax.ForInitializer
forInitializerStatements x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForInitializer"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "statements"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the variable variant of hydra.ext.csharp.syntax.ForInitializer
forInitializerVariable :: Typed.TypedTerm Syntax.LocalVariableDeclaration -> Typed.TypedTerm Syntax.ForInitializer
forInitializerVariable x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForInitializer"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "variable"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.csharp.syntax.ForStatement
forStatement :: Typed.TypedTerm (Maybe Syntax.ForInitializer) -> Typed.TypedTerm (Maybe Syntax.BooleanExpression) -> Typed.TypedTerm (Maybe Syntax.StatementExpressionList) -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.ForStatement
forStatement initializer condition iterator body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Typed.unTypedTerm initializer)},
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Typed.unTypedTerm condition)},
        Model.Field {
          Model.fieldName = (Model.Name "iterator"),
          Model.fieldTerm = (Typed.unTypedTerm iterator)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.ForStatement
forStatementBody :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm Syntax.EmbeddedStatement
forStatementBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the condition field of hydra.ext.csharp.syntax.ForStatement
forStatementCondition :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm (Maybe Syntax.BooleanExpression)
forStatementCondition x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"),
        Model.projectionFieldName = (Model.Name "condition")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.ForStatement
forStatementForStatement :: Typed.TypedName Syntax.ForStatement
forStatementForStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ForStatement")

-- | DSL accessor for the initializer field of hydra.ext.csharp.syntax.ForStatement
forStatementInitializer :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm (Maybe Syntax.ForInitializer)
forStatementInitializer x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"),
        Model.projectionFieldName = (Model.Name "initializer")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the iterator field of hydra.ext.csharp.syntax.ForStatement
forStatementIterator :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm (Maybe Syntax.StatementExpressionList)
forStatementIterator x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"),
        Model.projectionFieldName = (Model.Name "iterator")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the body field of hydra.ext.csharp.syntax.ForStatement
forStatementWithBody :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.ForStatement
forStatementWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"),
              Model.projectionFieldName = (Model.Name "initializer")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"),
              Model.projectionFieldName = (Model.Name "condition")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "iterator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"),
              Model.projectionFieldName = (Model.Name "iterator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the condition field of hydra.ext.csharp.syntax.ForStatement
forStatementWithCondition :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm (Maybe Syntax.BooleanExpression) -> Typed.TypedTerm Syntax.ForStatement
forStatementWithCondition original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"),
              Model.projectionFieldName = (Model.Name "initializer")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "iterator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"),
              Model.projectionFieldName = (Model.Name "iterator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the initializer field of hydra.ext.csharp.syntax.ForStatement
forStatementWithInitializer :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm (Maybe Syntax.ForInitializer) -> Typed.TypedTerm Syntax.ForStatement
forStatementWithInitializer original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"),
              Model.projectionFieldName = (Model.Name "condition")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "iterator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"),
              Model.projectionFieldName = (Model.Name "iterator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the iterator field of hydra.ext.csharp.syntax.ForStatement
forStatementWithIterator :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm (Maybe Syntax.StatementExpressionList) -> Typed.TypedTerm Syntax.ForStatement
forStatementWithIterator original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"),
              Model.projectionFieldName = (Model.Name "initializer")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"),
              Model.projectionFieldName = (Model.Name "condition")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "iterator"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForStatement"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.ForeachStatement
foreachStatement :: Typed.TypedTerm (Maybe Syntax.RefKind) -> Typed.TypedTerm Syntax.LocalVariableType -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.ForeachStatement
foreachStatement kind type_ identifier expression body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "kind"),
          Model.fieldTerm = (Typed.unTypedTerm kind)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm identifier)},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm expression)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.ForeachStatement
foreachStatementBody :: Typed.TypedTerm Syntax.ForeachStatement -> Typed.TypedTerm Syntax.EmbeddedStatement
foreachStatementBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.ForeachStatement
foreachStatementExpression :: Typed.TypedTerm Syntax.ForeachStatement -> Typed.TypedTerm Syntax.Expression
foreachStatementExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"),
        Model.projectionFieldName = (Model.Name "expression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.ForeachStatement
foreachStatementForeachStatement :: Typed.TypedName Syntax.ForeachStatement
foreachStatementForeachStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ForeachStatement")

-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.ForeachStatement
foreachStatementIdentifier :: Typed.TypedTerm Syntax.ForeachStatement -> Typed.TypedTerm Syntax.Identifier
foreachStatementIdentifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"),
        Model.projectionFieldName = (Model.Name "identifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the kind field of hydra.ext.csharp.syntax.ForeachStatement
foreachStatementKind :: Typed.TypedTerm Syntax.ForeachStatement -> Typed.TypedTerm (Maybe Syntax.RefKind)
foreachStatementKind x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"),
        Model.projectionFieldName = (Model.Name "kind")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.ForeachStatement
foreachStatementType :: Typed.TypedTerm Syntax.ForeachStatement -> Typed.TypedTerm Syntax.LocalVariableType
foreachStatementType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the body field of hydra.ext.csharp.syntax.ForeachStatement
foreachStatementWithBody :: Typed.TypedTerm Syntax.ForeachStatement -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.ForeachStatement
foreachStatementWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "kind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"),
              Model.projectionFieldName = (Model.Name "kind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the expression field of hydra.ext.csharp.syntax.ForeachStatement
foreachStatementWithExpression :: Typed.TypedTerm Syntax.ForeachStatement -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ForeachStatement
foreachStatementWithExpression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "kind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"),
              Model.projectionFieldName = (Model.Name "kind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.ForeachStatement
foreachStatementWithIdentifier :: Typed.TypedTerm Syntax.ForeachStatement -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ForeachStatement
foreachStatementWithIdentifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "kind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"),
              Model.projectionFieldName = (Model.Name "kind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the kind field of hydra.ext.csharp.syntax.ForeachStatement
foreachStatementWithKind :: Typed.TypedTerm Syntax.ForeachStatement -> Typed.TypedTerm (Maybe Syntax.RefKind) -> Typed.TypedTerm Syntax.ForeachStatement
foreachStatementWithKind original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "kind"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.ForeachStatement
foreachStatementWithType :: Typed.TypedTerm Syntax.ForeachStatement -> Typed.TypedTerm Syntax.LocalVariableType -> Typed.TypedTerm Syntax.ForeachStatement
foreachStatementWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "kind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"),
              Model.projectionFieldName = (Model.Name "kind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ForeachStatement"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.FormalParameterList
formalParameterList :: Typed.TypedTerm [Syntax.FixedParameter] -> Typed.TypedTerm (Maybe Syntax.ParameterArray) -> Typed.TypedTerm Syntax.FormalParameterList
formalParameterList fixed array =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FormalParameterList"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "fixed"),
          Model.fieldTerm = (Typed.unTypedTerm fixed)},
        Model.Field {
          Model.fieldName = (Model.Name "array"),
          Model.fieldTerm = (Typed.unTypedTerm array)}]}))

-- | DSL accessor for the array field of hydra.ext.csharp.syntax.FormalParameterList
formalParameterListArray :: Typed.TypedTerm Syntax.FormalParameterList -> Typed.TypedTerm (Maybe Syntax.ParameterArray)
formalParameterListArray x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FormalParameterList"),
        Model.projectionFieldName = (Model.Name "array")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the fixed field of hydra.ext.csharp.syntax.FormalParameterList
formalParameterListFixed :: Typed.TypedTerm Syntax.FormalParameterList -> Typed.TypedTerm [Syntax.FixedParameter]
formalParameterListFixed x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FormalParameterList"),
        Model.projectionFieldName = (Model.Name "fixed")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.FormalParameterList
formalParameterListFormalParameterList :: Typed.TypedName Syntax.FormalParameterList
formalParameterListFormalParameterList = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.FormalParameterList")

-- | DSL updater for the array field of hydra.ext.csharp.syntax.FormalParameterList
formalParameterListWithArray :: Typed.TypedTerm Syntax.FormalParameterList -> Typed.TypedTerm (Maybe Syntax.ParameterArray) -> Typed.TypedTerm Syntax.FormalParameterList
formalParameterListWithArray original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FormalParameterList"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "fixed"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FormalParameterList"),
              Model.projectionFieldName = (Model.Name "fixed")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "array"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the fixed field of hydra.ext.csharp.syntax.FormalParameterList
formalParameterListWithFixed :: Typed.TypedTerm Syntax.FormalParameterList -> Typed.TypedTerm [Syntax.FixedParameter] -> Typed.TypedTerm Syntax.FormalParameterList
formalParameterListWithFixed original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FormalParameterList"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "fixed"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "array"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FormalParameterList"),
              Model.projectionFieldName = (Model.Name "array")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.FromClause
fromClause :: Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.FromClause
fromClause type_ identifier in_ =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FromClause"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm identifier)},
        Model.Field {
          Model.fieldName = (Model.Name "in"),
          Model.fieldTerm = (Typed.unTypedTerm in_)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.FromClause
fromClauseFromClause :: Typed.TypedName Syntax.FromClause
fromClauseFromClause = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.FromClause")

-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.FromClause
fromClauseIdentifier :: Typed.TypedTerm Syntax.FromClause -> Typed.TypedTerm Syntax.Identifier
fromClauseIdentifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FromClause"),
        Model.projectionFieldName = (Model.Name "identifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the in field of hydra.ext.csharp.syntax.FromClause
fromClauseIn :: Typed.TypedTerm Syntax.FromClause -> Typed.TypedTerm Syntax.Expression
fromClauseIn x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FromClause"),
        Model.projectionFieldName = (Model.Name "in")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.FromClause
fromClauseType :: Typed.TypedTerm Syntax.FromClause -> Typed.TypedTerm (Maybe Syntax.Type)
fromClauseType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FromClause"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.FromClause
fromClauseWithIdentifier :: Typed.TypedTerm Syntax.FromClause -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.FromClause
fromClauseWithIdentifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FromClause"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FromClause"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "in"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FromClause"),
              Model.projectionFieldName = (Model.Name "in")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the in field of hydra.ext.csharp.syntax.FromClause
fromClauseWithIn :: Typed.TypedTerm Syntax.FromClause -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.FromClause
fromClauseWithIn original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FromClause"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FromClause"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FromClause"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "in"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.FromClause
fromClauseWithType :: Typed.TypedTerm Syntax.FromClause -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.FromClause
fromClauseWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.FromClause"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FromClause"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "in"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.FromClause"),
              Model.projectionFieldName = (Model.Name "in")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.GlobalAttributeSection
globalAttributeSection :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.AttributeList -> Typed.TypedTerm Syntax.GlobalAttributeSection
globalAttributeSection target attributes =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.GlobalAttributeSection"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "target"),
          Model.fieldTerm = (Typed.unTypedTerm target)},
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)}]}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.GlobalAttributeSection
globalAttributeSectionAttributes :: Typed.TypedTerm Syntax.GlobalAttributeSection -> Typed.TypedTerm Syntax.AttributeList
globalAttributeSectionAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.GlobalAttributeSection"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.GlobalAttributeSection
globalAttributeSectionGlobalAttributeSection :: Typed.TypedName Syntax.GlobalAttributeSection
globalAttributeSectionGlobalAttributeSection =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.GlobalAttributeSection")

-- | DSL accessor for the target field of hydra.ext.csharp.syntax.GlobalAttributeSection
globalAttributeSectionTarget :: Typed.TypedTerm Syntax.GlobalAttributeSection -> Typed.TypedTerm Syntax.Identifier
globalAttributeSectionTarget x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.GlobalAttributeSection"),
        Model.projectionFieldName = (Model.Name "target")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.GlobalAttributeSection
globalAttributeSectionWithAttributes :: Typed.TypedTerm Syntax.GlobalAttributeSection -> Typed.TypedTerm Syntax.AttributeList -> Typed.TypedTerm Syntax.GlobalAttributeSection
globalAttributeSectionWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.GlobalAttributeSection"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "target"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.GlobalAttributeSection"),
              Model.projectionFieldName = (Model.Name "target")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the target field of hydra.ext.csharp.syntax.GlobalAttributeSection
globalAttributeSectionWithTarget :: Typed.TypedTerm Syntax.GlobalAttributeSection -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.GlobalAttributeSection
globalAttributeSectionWithTarget original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.GlobalAttributeSection"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "target"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.GlobalAttributeSection"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the case variant of hydra.ext.csharp.syntax.GotoStatement
gotoStatementCase :: Typed.TypedTerm Syntax.ConstantExpression -> Typed.TypedTerm Syntax.GotoStatement
gotoStatementCase x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.GotoStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "case"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the default variant of hydra.ext.csharp.syntax.GotoStatement
gotoStatementDefault :: Typed.TypedTerm Syntax.GotoStatement
gotoStatementDefault =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.GotoStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "default"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.csharp.syntax.GotoStatement
gotoStatementGotoStatement :: Typed.TypedName Syntax.GotoStatement
gotoStatementGotoStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.GotoStatement")

-- | DSL injection for the identifier variant of hydra.ext.csharp.syntax.GotoStatement
gotoStatementIdentifier :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.GotoStatement
gotoStatementIdentifier x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.GotoStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "identifier"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.csharp.syntax.GroupClause
groupClause :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.GroupClause
groupClause grouped by =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.GroupClause"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "grouped"),
          Model.fieldTerm = (Typed.unTypedTerm grouped)},
        Model.Field {
          Model.fieldName = (Model.Name "by"),
          Model.fieldTerm = (Typed.unTypedTerm by)}]}))

-- | DSL accessor for the by field of hydra.ext.csharp.syntax.GroupClause
groupClauseBy :: Typed.TypedTerm Syntax.GroupClause -> Typed.TypedTerm Syntax.Expression
groupClauseBy x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.GroupClause"),
        Model.projectionFieldName = (Model.Name "by")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.GroupClause
groupClauseGroupClause :: Typed.TypedName Syntax.GroupClause
groupClauseGroupClause = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.GroupClause")

-- | DSL accessor for the grouped field of hydra.ext.csharp.syntax.GroupClause
groupClauseGrouped :: Typed.TypedTerm Syntax.GroupClause -> Typed.TypedTerm Syntax.Expression
groupClauseGrouped x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.GroupClause"),
        Model.projectionFieldName = (Model.Name "grouped")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the by field of hydra.ext.csharp.syntax.GroupClause
groupClauseWithBy :: Typed.TypedTerm Syntax.GroupClause -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.GroupClause
groupClauseWithBy original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.GroupClause"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "grouped"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.GroupClause"),
              Model.projectionFieldName = (Model.Name "grouped")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "by"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the grouped field of hydra.ext.csharp.syntax.GroupClause
groupClauseWithGrouped :: Typed.TypedTerm Syntax.GroupClause -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.GroupClause
groupClauseWithGrouped original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.GroupClause"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "grouped"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "by"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.GroupClause"),
              Model.projectionFieldName = (Model.Name "by")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for the hydra.ext.csharp.syntax.Identifier wrapper
identifier :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Identifier
identifier x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.Identifier"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.Identifier
identifierIdentifier :: Typed.TypedName Syntax.Identifier
identifierIdentifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.Identifier")

-- | DSL constructor for hydra.ext.csharp.syntax.IdentifierNamespaceOrTypeName
identifierNamespaceOrTypeName :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.IdentifierNamespaceOrTypeName
identifierNamespaceOrTypeName identifier arguments =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IdentifierNamespaceOrTypeName"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm identifier)},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Typed.unTypedTerm arguments)}]}))

-- | DSL accessor for the arguments field of hydra.ext.csharp.syntax.IdentifierNamespaceOrTypeName
identifierNamespaceOrTypeNameArguments :: Typed.TypedTerm Syntax.IdentifierNamespaceOrTypeName -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList)
identifierNamespaceOrTypeNameArguments x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IdentifierNamespaceOrTypeName"),
        Model.projectionFieldName = (Model.Name "arguments")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.IdentifierNamespaceOrTypeName
identifierNamespaceOrTypeNameIdentifier :: Typed.TypedTerm Syntax.IdentifierNamespaceOrTypeName -> Typed.TypedTerm Syntax.Identifier
identifierNamespaceOrTypeNameIdentifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IdentifierNamespaceOrTypeName"),
        Model.projectionFieldName = (Model.Name "identifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.IdentifierNamespaceOrTypeName
identifierNamespaceOrTypeNameIdentifierNamespaceOrTypeName :: Typed.TypedName Syntax.IdentifierNamespaceOrTypeName
identifierNamespaceOrTypeNameIdentifierNamespaceOrTypeName =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.IdentifierNamespaceOrTypeName")

-- | DSL updater for the arguments field of hydra.ext.csharp.syntax.IdentifierNamespaceOrTypeName
identifierNamespaceOrTypeNameWithArguments :: Typed.TypedTerm Syntax.IdentifierNamespaceOrTypeName -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.IdentifierNamespaceOrTypeName
identifierNamespaceOrTypeNameWithArguments original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IdentifierNamespaceOrTypeName"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IdentifierNamespaceOrTypeName"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.IdentifierNamespaceOrTypeName
identifierNamespaceOrTypeNameWithIdentifier :: Typed.TypedTerm Syntax.IdentifierNamespaceOrTypeName -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.IdentifierNamespaceOrTypeName
identifierNamespaceOrTypeNameWithIdentifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IdentifierNamespaceOrTypeName"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IdentifierNamespaceOrTypeName"),
              Model.projectionFieldName = (Model.Name "arguments")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.IfStatement
ifStatement :: Typed.TypedTerm Syntax.BooleanExpression -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.IfStatement
ifStatement condition ifBranch elseBranch =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IfStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Typed.unTypedTerm condition)},
        Model.Field {
          Model.fieldName = (Model.Name "ifBranch"),
          Model.fieldTerm = (Typed.unTypedTerm ifBranch)},
        Model.Field {
          Model.fieldName = (Model.Name "elseBranch"),
          Model.fieldTerm = (Typed.unTypedTerm elseBranch)}]}))

-- | DSL accessor for the condition field of hydra.ext.csharp.syntax.IfStatement
ifStatementCondition :: Typed.TypedTerm Syntax.IfStatement -> Typed.TypedTerm Syntax.BooleanExpression
ifStatementCondition x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IfStatement"),
        Model.projectionFieldName = (Model.Name "condition")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the elseBranch field of hydra.ext.csharp.syntax.IfStatement
ifStatementElseBranch :: Typed.TypedTerm Syntax.IfStatement -> Typed.TypedTerm Syntax.EmbeddedStatement
ifStatementElseBranch x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IfStatement"),
        Model.projectionFieldName = (Model.Name "elseBranch")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the ifBranch field of hydra.ext.csharp.syntax.IfStatement
ifStatementIfBranch :: Typed.TypedTerm Syntax.IfStatement -> Typed.TypedTerm Syntax.EmbeddedStatement
ifStatementIfBranch x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IfStatement"),
        Model.projectionFieldName = (Model.Name "ifBranch")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.IfStatement
ifStatementIfStatement :: Typed.TypedName Syntax.IfStatement
ifStatementIfStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.IfStatement")

-- | DSL updater for the condition field of hydra.ext.csharp.syntax.IfStatement
ifStatementWithCondition :: Typed.TypedTerm Syntax.IfStatement -> Typed.TypedTerm Syntax.BooleanExpression -> Typed.TypedTerm Syntax.IfStatement
ifStatementWithCondition original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IfStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "ifBranch"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IfStatement"),
              Model.projectionFieldName = (Model.Name "ifBranch")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "elseBranch"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IfStatement"),
              Model.projectionFieldName = (Model.Name "elseBranch")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the elseBranch field of hydra.ext.csharp.syntax.IfStatement
ifStatementWithElseBranch :: Typed.TypedTerm Syntax.IfStatement -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.IfStatement
ifStatementWithElseBranch original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IfStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IfStatement"),
              Model.projectionFieldName = (Model.Name "condition")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "ifBranch"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IfStatement"),
              Model.projectionFieldName = (Model.Name "ifBranch")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "elseBranch"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the ifBranch field of hydra.ext.csharp.syntax.IfStatement
ifStatementWithIfBranch :: Typed.TypedTerm Syntax.IfStatement -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.IfStatement
ifStatementWithIfBranch original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IfStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IfStatement"),
              Model.projectionFieldName = (Model.Name "condition")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "ifBranch"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "elseBranch"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IfStatement"),
              Model.projectionFieldName = (Model.Name "elseBranch")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL name token for hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclaration
implicitlyTypedLocalVariableDeclarationImplicitlyTypedLocalVariableDeclaration :: Typed.TypedName Syntax.ImplicitlyTypedLocalVariableDeclaration
implicitlyTypedLocalVariableDeclarationImplicitlyTypedLocalVariableDeclaration =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclaration")

-- | DSL injection for the refVar variant of hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclaration
implicitlyTypedLocalVariableDeclarationRefVar :: Typed.TypedTerm Syntax.RefVarImplicitlyTypedLocalVariableDeclaration -> Typed.TypedTerm Syntax.ImplicitlyTypedLocalVariableDeclaration
implicitlyTypedLocalVariableDeclarationRefVar x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "refVar"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the var variant of hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclaration
implicitlyTypedLocalVariableDeclarationVar :: Typed.TypedTerm Syntax.ImplicitlyTypedLocalVariableDeclarator -> Typed.TypedTerm Syntax.ImplicitlyTypedLocalVariableDeclaration
implicitlyTypedLocalVariableDeclarationVar x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "var"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator
implicitlyTypedLocalVariableDeclarator :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ImplicitlyTypedLocalVariableDeclarator
implicitlyTypedLocalVariableDeclarator identifier expression =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm identifier)},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm expression)}]}))

-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator
implicitlyTypedLocalVariableDeclaratorExpression :: Typed.TypedTerm Syntax.ImplicitlyTypedLocalVariableDeclarator -> Typed.TypedTerm Syntax.Expression
implicitlyTypedLocalVariableDeclaratorExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator"),
        Model.projectionFieldName = (Model.Name "expression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator
implicitlyTypedLocalVariableDeclaratorIdentifier :: Typed.TypedTerm Syntax.ImplicitlyTypedLocalVariableDeclarator -> Typed.TypedTerm Syntax.Identifier
implicitlyTypedLocalVariableDeclaratorIdentifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator"),
        Model.projectionFieldName = (Model.Name "identifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator
implicitlyTypedLocalVariableDeclaratorImplicitlyTypedLocalVariableDeclarator :: Typed.TypedName Syntax.ImplicitlyTypedLocalVariableDeclarator
implicitlyTypedLocalVariableDeclaratorImplicitlyTypedLocalVariableDeclarator =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator")

-- | DSL updater for the expression field of hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator
implicitlyTypedLocalVariableDeclaratorWithExpression :: Typed.TypedTerm Syntax.ImplicitlyTypedLocalVariableDeclarator -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ImplicitlyTypedLocalVariableDeclarator
implicitlyTypedLocalVariableDeclaratorWithExpression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator
implicitlyTypedLocalVariableDeclaratorWithIdentifier :: Typed.TypedTerm Syntax.ImplicitlyTypedLocalVariableDeclarator -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ImplicitlyTypedLocalVariableDeclarator
implicitlyTypedLocalVariableDeclaratorWithIdentifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the binary variant of hydra.ext.csharp.syntax.InclusiveOrExpression
inclusiveOrExpressionBinary :: Typed.TypedTerm Syntax.BinaryInclusiveOrExpression -> Typed.TypedTerm Syntax.InclusiveOrExpression
inclusiveOrExpressionBinary x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InclusiveOrExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "binary"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.InclusiveOrExpression
inclusiveOrExpressionInclusiveOrExpression :: Typed.TypedName Syntax.InclusiveOrExpression
inclusiveOrExpressionInclusiveOrExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InclusiveOrExpression")

-- | DSL injection for the simple variant of hydra.ext.csharp.syntax.InclusiveOrExpression
inclusiveOrExpressionSimple :: Typed.TypedTerm Syntax.ExclusiveOrExpression -> Typed.TypedTerm Syntax.InclusiveOrExpression
inclusiveOrExpressionSimple x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InclusiveOrExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "simple"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the block variant of hydra.ext.csharp.syntax.IndexerBody
indexerBodyBlock :: Typed.TypedTerm Syntax.AccessorDeclarations -> Typed.TypedTerm Syntax.IndexerBody
indexerBodyBlock x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "block"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.IndexerBody
indexerBodyExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.IndexerBody
indexerBodyExpression x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "expression"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.IndexerBody
indexerBodyIndexerBody :: Typed.TypedName Syntax.IndexerBody
indexerBodyIndexerBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.IndexerBody")

-- | DSL name token for hydra.ext.csharp.syntax.IndexerDeclaration
indexerDeclarationIndexerDeclaration :: Typed.TypedName Syntax.IndexerDeclaration
indexerDeclarationIndexerDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.IndexerDeclaration")

-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.IndexerDeclaration
indexerDeclarationRef :: Typed.TypedTerm Syntax.RefIndexerDeclaration -> Typed.TypedTerm Syntax.IndexerDeclaration
indexerDeclarationRef x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "ref"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the standard variant of hydra.ext.csharp.syntax.IndexerDeclaration
indexerDeclarationStandard :: Typed.TypedTerm Syntax.StandardIndexerDeclaration -> Typed.TypedTerm Syntax.IndexerDeclaration
indexerDeclarationStandard x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "standard"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.csharp.syntax.IndexerDeclarator
indexerDeclarator :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm (Maybe Syntax.InterfaceType) -> Typed.TypedTerm Syntax.FormalParameterList -> Typed.TypedTerm Syntax.IndexerDeclarator
indexerDeclarator type_ interface parameters =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "interface"),
          Model.fieldTerm = (Typed.unTypedTerm interface)},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm parameters)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.IndexerDeclarator
indexerDeclaratorIndexerDeclarator :: Typed.TypedName Syntax.IndexerDeclarator
indexerDeclaratorIndexerDeclarator = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.IndexerDeclarator")

-- | DSL accessor for the interface field of hydra.ext.csharp.syntax.IndexerDeclarator
indexerDeclaratorInterface :: Typed.TypedTerm Syntax.IndexerDeclarator -> Typed.TypedTerm (Maybe Syntax.InterfaceType)
indexerDeclaratorInterface x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerDeclarator"),
        Model.projectionFieldName = (Model.Name "interface")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the parameters field of hydra.ext.csharp.syntax.IndexerDeclarator
indexerDeclaratorParameters :: Typed.TypedTerm Syntax.IndexerDeclarator -> Typed.TypedTerm Syntax.FormalParameterList
indexerDeclaratorParameters x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerDeclarator"),
        Model.projectionFieldName = (Model.Name "parameters")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.IndexerDeclarator
indexerDeclaratorType :: Typed.TypedTerm Syntax.IndexerDeclarator -> Typed.TypedTerm Syntax.Type
indexerDeclaratorType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerDeclarator"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the interface field of hydra.ext.csharp.syntax.IndexerDeclarator
indexerDeclaratorWithInterface :: Typed.TypedTerm Syntax.IndexerDeclarator -> Typed.TypedTerm (Maybe Syntax.InterfaceType) -> Typed.TypedTerm Syntax.IndexerDeclarator
indexerDeclaratorWithInterface original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerDeclarator"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "interface"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerDeclarator"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the parameters field of hydra.ext.csharp.syntax.IndexerDeclarator
indexerDeclaratorWithParameters :: Typed.TypedTerm Syntax.IndexerDeclarator -> Typed.TypedTerm Syntax.FormalParameterList -> Typed.TypedTerm Syntax.IndexerDeclarator
indexerDeclaratorWithParameters original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerDeclarator"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "interface"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerDeclarator"),
              Model.projectionFieldName = (Model.Name "interface")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.IndexerDeclarator
indexerDeclaratorWithType :: Typed.TypedTerm Syntax.IndexerDeclarator -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.IndexerDeclarator
indexerDeclaratorWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "interface"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerDeclarator"),
              Model.projectionFieldName = (Model.Name "interface")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerDeclarator"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the abstract variant of hydra.ext.csharp.syntax.IndexerModifier
indexerModifierAbstract :: Typed.TypedTerm Syntax.IndexerModifier
indexerModifierAbstract =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "abstract"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the extern variant of hydra.ext.csharp.syntax.IndexerModifier
indexerModifierExtern :: Typed.TypedTerm Syntax.IndexerModifier
indexerModifierExtern =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "extern"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.csharp.syntax.IndexerModifier
indexerModifierIndexerModifier :: Typed.TypedName Syntax.IndexerModifier
indexerModifierIndexerModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.IndexerModifier")

-- | DSL injection for the internal variant of hydra.ext.csharp.syntax.IndexerModifier
indexerModifierInternal :: Typed.TypedTerm Syntax.IndexerModifier
indexerModifierInternal =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "internal"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the new variant of hydra.ext.csharp.syntax.IndexerModifier
indexerModifierNew :: Typed.TypedTerm Syntax.IndexerModifier
indexerModifierNew =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "new"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the override variant of hydra.ext.csharp.syntax.IndexerModifier
indexerModifierOverride :: Typed.TypedTerm Syntax.IndexerModifier
indexerModifierOverride =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "override"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the private variant of hydra.ext.csharp.syntax.IndexerModifier
indexerModifierPrivate :: Typed.TypedTerm Syntax.IndexerModifier
indexerModifierPrivate =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "private"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the protected variant of hydra.ext.csharp.syntax.IndexerModifier
indexerModifierProtected :: Typed.TypedTerm Syntax.IndexerModifier
indexerModifierProtected =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "protected"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the public variant of hydra.ext.csharp.syntax.IndexerModifier
indexerModifierPublic :: Typed.TypedTerm Syntax.IndexerModifier
indexerModifierPublic =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "public"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the sealed variant of hydra.ext.csharp.syntax.IndexerModifier
indexerModifierSealed :: Typed.TypedTerm Syntax.IndexerModifier
indexerModifierSealed =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "sealed"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the unsafe variant of hydra.ext.csharp.syntax.IndexerModifier
indexerModifierUnsafe :: Typed.TypedTerm Syntax.IndexerModifier
indexerModifierUnsafe =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "unsafe"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the virtual variant of hydra.ext.csharp.syntax.IndexerModifier
indexerModifierVirtual :: Typed.TypedTerm Syntax.IndexerModifier
indexerModifierVirtual =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IndexerModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "virtual"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the arguments variant of hydra.ext.csharp.syntax.InitializerTarget
initializerTargetArguments :: Typed.TypedTerm Syntax.ArgumentList -> Typed.TypedTerm Syntax.InitializerTarget
initializerTargetArguments x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InitializerTarget"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "arguments"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the identifier variant of hydra.ext.csharp.syntax.InitializerTarget
initializerTargetIdentifier :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.InitializerTarget
initializerTargetIdentifier x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InitializerTarget"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "identifier"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.InitializerTarget
initializerTargetInitializerTarget :: Typed.TypedName Syntax.InitializerTarget
initializerTargetInitializerTarget = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InitializerTarget")

-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.InitializerValue
initializerValueExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.InitializerValue
initializerValueExpression x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InitializerValue"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "expression"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.InitializerValue
initializerValueInitializerValue :: Typed.TypedName Syntax.InitializerValue
initializerValueInitializerValue = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InitializerValue")

-- | DSL injection for the objectOrCollection variant of hydra.ext.csharp.syntax.InitializerValue
initializerValueObjectOrCollection :: Typed.TypedTerm Syntax.ObjectOrCollectionInitializer -> Typed.TypedTerm Syntax.InitializerValue
initializerValueObjectOrCollection x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InitializerValue"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "objectOrCollection"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the binary variant of hydra.ext.csharp.syntax.IntegerLiteral
integerLiteralBinary :: Typed.TypedTerm Integer -> Typed.TypedTerm Syntax.IntegerLiteral
integerLiteralBinary x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IntegerLiteral"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "binary"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the decimal variant of hydra.ext.csharp.syntax.IntegerLiteral
integerLiteralDecimal :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.IntegerLiteral
integerLiteralDecimal x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IntegerLiteral"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "decimal"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the hexadecimal variant of hydra.ext.csharp.syntax.IntegerLiteral
integerLiteralHexadecimal :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.IntegerLiteral
integerLiteralHexadecimal x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IntegerLiteral"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "hexadecimal"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.IntegerLiteral
integerLiteralIntegerLiteral :: Typed.TypedName Syntax.IntegerLiteral
integerLiteralIntegerLiteral = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.IntegerLiteral")

-- | DSL injection for the byte variant of hydra.ext.csharp.syntax.IntegralType
integralTypeByte :: Typed.TypedTerm Syntax.IntegralType
integralTypeByte =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IntegralType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "byte"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the char variant of hydra.ext.csharp.syntax.IntegralType
integralTypeChar :: Typed.TypedTerm Syntax.IntegralType
integralTypeChar =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IntegralType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "char"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the int variant of hydra.ext.csharp.syntax.IntegralType
integralTypeInt :: Typed.TypedTerm Syntax.IntegralType
integralTypeInt =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IntegralType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "int"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.csharp.syntax.IntegralType
integralTypeIntegralType :: Typed.TypedName Syntax.IntegralType
integralTypeIntegralType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.IntegralType")

-- | DSL injection for the long variant of hydra.ext.csharp.syntax.IntegralType
integralTypeLong :: Typed.TypedTerm Syntax.IntegralType
integralTypeLong =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IntegralType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "long"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the sbyte variant of hydra.ext.csharp.syntax.IntegralType
integralTypeSbyte :: Typed.TypedTerm Syntax.IntegralType
integralTypeSbyte =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IntegralType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "sbyte"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the short variant of hydra.ext.csharp.syntax.IntegralType
integralTypeShort :: Typed.TypedTerm Syntax.IntegralType
integralTypeShort =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IntegralType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "short"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the uint variant of hydra.ext.csharp.syntax.IntegralType
integralTypeUint :: Typed.TypedTerm Syntax.IntegralType
integralTypeUint =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IntegralType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "uint"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the ulong variant of hydra.ext.csharp.syntax.IntegralType
integralTypeUlong :: Typed.TypedTerm Syntax.IntegralType
integralTypeUlong =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IntegralType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "ulong"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the ushort variant of hydra.ext.csharp.syntax.IntegralType
integralTypeUshort :: Typed.TypedTerm Syntax.IntegralType
integralTypeUshort =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IntegralType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "ushort"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL constructor for hydra.ext.csharp.syntax.InterfaceAccessors
interfaceAccessors :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.InterfaceAccessors
interfaceAccessors attributes get set =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceAccessors"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "get"),
          Model.fieldTerm = (Typed.unTypedTerm get)},
        Model.Field {
          Model.fieldName = (Model.Name "set"),
          Model.fieldTerm = (Typed.unTypedTerm set)}]}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.InterfaceAccessors
interfaceAccessorsAttributes :: Typed.TypedTerm Syntax.InterfaceAccessors -> Typed.TypedTerm (Maybe Syntax.Attributes)
interfaceAccessorsAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceAccessors"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the get field of hydra.ext.csharp.syntax.InterfaceAccessors
interfaceAccessorsGet :: Typed.TypedTerm Syntax.InterfaceAccessors -> Typed.TypedTerm (Maybe Syntax.Attributes)
interfaceAccessorsGet x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceAccessors"),
        Model.projectionFieldName = (Model.Name "get")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.InterfaceAccessors
interfaceAccessorsInterfaceAccessors :: Typed.TypedName Syntax.InterfaceAccessors
interfaceAccessorsInterfaceAccessors = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InterfaceAccessors")

-- | DSL accessor for the set field of hydra.ext.csharp.syntax.InterfaceAccessors
interfaceAccessorsSet :: Typed.TypedTerm Syntax.InterfaceAccessors -> Typed.TypedTerm (Maybe Syntax.Attributes)
interfaceAccessorsSet x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceAccessors"),
        Model.projectionFieldName = (Model.Name "set")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.InterfaceAccessors
interfaceAccessorsWithAttributes :: Typed.TypedTerm Syntax.InterfaceAccessors -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.InterfaceAccessors
interfaceAccessorsWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceAccessors"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "get"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceAccessors"),
              Model.projectionFieldName = (Model.Name "get")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "set"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceAccessors"),
              Model.projectionFieldName = (Model.Name "set")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the get field of hydra.ext.csharp.syntax.InterfaceAccessors
interfaceAccessorsWithGet :: Typed.TypedTerm Syntax.InterfaceAccessors -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.InterfaceAccessors
interfaceAccessorsWithGet original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceAccessors"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceAccessors"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "get"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "set"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceAccessors"),
              Model.projectionFieldName = (Model.Name "set")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the set field of hydra.ext.csharp.syntax.InterfaceAccessors
interfaceAccessorsWithSet :: Typed.TypedTerm Syntax.InterfaceAccessors -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.InterfaceAccessors
interfaceAccessorsWithSet original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceAccessors"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceAccessors"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "get"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceAccessors"),
              Model.projectionFieldName = (Model.Name "get")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "set"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.InterfaceDeclaration
interfaceDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.InterfaceModifier] -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.VariantTypeParameters) -> Typed.TypedTerm [Syntax.InterfaceType] -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] -> Typed.TypedTerm [Syntax.InterfaceMemberDeclaration] -> Typed.TypedTerm Syntax.InterfaceDeclaration
interfaceDeclaration attributes modifiers partial name parameters base constraints body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm modifiers)},
        Model.Field {
          Model.fieldName = (Model.Name "partial"),
          Model.fieldTerm = (Typed.unTypedTerm partial)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm parameters)},
        Model.Field {
          Model.fieldName = (Model.Name "base"),
          Model.fieldTerm = (Typed.unTypedTerm base)},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Typed.unTypedTerm constraints)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.InterfaceDeclaration
interfaceDeclarationAttributes :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes)
interfaceDeclarationAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the base field of hydra.ext.csharp.syntax.InterfaceDeclaration
interfaceDeclarationBase :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm [Syntax.InterfaceType]
interfaceDeclarationBase x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
        Model.projectionFieldName = (Model.Name "base")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.InterfaceDeclaration
interfaceDeclarationBody :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm [Syntax.InterfaceMemberDeclaration]
interfaceDeclarationBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the constraints field of hydra.ext.csharp.syntax.InterfaceDeclaration
interfaceDeclarationConstraints :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause]
interfaceDeclarationConstraints x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
        Model.projectionFieldName = (Model.Name "constraints")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.InterfaceDeclaration
interfaceDeclarationInterfaceDeclaration :: Typed.TypedName Syntax.InterfaceDeclaration
interfaceDeclarationInterfaceDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration")

-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.InterfaceDeclaration
interfaceDeclarationModifiers :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm [Syntax.InterfaceModifier]
interfaceDeclarationModifiers x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
        Model.projectionFieldName = (Model.Name "modifiers")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the name field of hydra.ext.csharp.syntax.InterfaceDeclaration
interfaceDeclarationName :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm Syntax.Identifier
interfaceDeclarationName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the parameters field of hydra.ext.csharp.syntax.InterfaceDeclaration
interfaceDeclarationParameters :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm (Maybe Syntax.VariantTypeParameters)
interfaceDeclarationParameters x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
        Model.projectionFieldName = (Model.Name "parameters")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the partial field of hydra.ext.csharp.syntax.InterfaceDeclaration
interfaceDeclarationPartial :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm Bool
interfaceDeclarationPartial x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
        Model.projectionFieldName = (Model.Name "partial")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.InterfaceDeclaration
interfaceDeclarationWithAttributes :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.InterfaceDeclaration
interfaceDeclarationWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "partial"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "partial")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "base"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "base")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the base field of hydra.ext.csharp.syntax.InterfaceDeclaration
interfaceDeclarationWithBase :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm [Syntax.InterfaceType] -> Typed.TypedTerm Syntax.InterfaceDeclaration
interfaceDeclarationWithBase original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "partial"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "partial")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "base"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the body field of hydra.ext.csharp.syntax.InterfaceDeclaration
interfaceDeclarationWithBody :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm [Syntax.InterfaceMemberDeclaration] -> Typed.TypedTerm Syntax.InterfaceDeclaration
interfaceDeclarationWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "partial"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "partial")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "base"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "base")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the constraints field of hydra.ext.csharp.syntax.InterfaceDeclaration
interfaceDeclarationWithConstraints :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] -> Typed.TypedTerm Syntax.InterfaceDeclaration
interfaceDeclarationWithConstraints original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "partial"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "partial")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "base"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "base")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.InterfaceDeclaration
interfaceDeclarationWithModifiers :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm [Syntax.InterfaceModifier] -> Typed.TypedTerm Syntax.InterfaceDeclaration
interfaceDeclarationWithModifiers original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "partial"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "partial")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "base"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "base")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.csharp.syntax.InterfaceDeclaration
interfaceDeclarationWithName :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.InterfaceDeclaration
interfaceDeclarationWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "partial"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "partial")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "base"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "base")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the parameters field of hydra.ext.csharp.syntax.InterfaceDeclaration
interfaceDeclarationWithParameters :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm (Maybe Syntax.VariantTypeParameters) -> Typed.TypedTerm Syntax.InterfaceDeclaration
interfaceDeclarationWithParameters original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "partial"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "partial")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "base"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "base")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the partial field of hydra.ext.csharp.syntax.InterfaceDeclaration
interfaceDeclarationWithPartial :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.InterfaceDeclaration
interfaceDeclarationWithPartial original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "partial"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "base"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "base")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.InterfaceEventDeclaration
interfaceEventDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.InterfaceEventDeclaration
interfaceEventDeclaration attributes new type_ name =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "new"),
          Model.fieldTerm = (Typed.unTypedTerm new)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)}]}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.InterfaceEventDeclaration
interfaceEventDeclarationAttributes :: Typed.TypedTerm Syntax.InterfaceEventDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes)
interfaceEventDeclarationAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.InterfaceEventDeclaration
interfaceEventDeclarationInterfaceEventDeclaration :: Typed.TypedName Syntax.InterfaceEventDeclaration
interfaceEventDeclarationInterfaceEventDeclaration =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration")

-- | DSL accessor for the name field of hydra.ext.csharp.syntax.InterfaceEventDeclaration
interfaceEventDeclarationName :: Typed.TypedTerm Syntax.InterfaceEventDeclaration -> Typed.TypedTerm Syntax.Identifier
interfaceEventDeclarationName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the new field of hydra.ext.csharp.syntax.InterfaceEventDeclaration
interfaceEventDeclarationNew :: Typed.TypedTerm Syntax.InterfaceEventDeclaration -> Typed.TypedTerm Bool
interfaceEventDeclarationNew x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"),
        Model.projectionFieldName = (Model.Name "new")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.InterfaceEventDeclaration
interfaceEventDeclarationType :: Typed.TypedTerm Syntax.InterfaceEventDeclaration -> Typed.TypedTerm Syntax.Type
interfaceEventDeclarationType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.InterfaceEventDeclaration
interfaceEventDeclarationWithAttributes :: Typed.TypedTerm Syntax.InterfaceEventDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.InterfaceEventDeclaration
interfaceEventDeclarationWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "new"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"),
              Model.projectionFieldName = (Model.Name "new")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.csharp.syntax.InterfaceEventDeclaration
interfaceEventDeclarationWithName :: Typed.TypedTerm Syntax.InterfaceEventDeclaration -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.InterfaceEventDeclaration
interfaceEventDeclarationWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "new"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"),
              Model.projectionFieldName = (Model.Name "new")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the new field of hydra.ext.csharp.syntax.InterfaceEventDeclaration
interfaceEventDeclarationWithNew :: Typed.TypedTerm Syntax.InterfaceEventDeclaration -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.InterfaceEventDeclaration
interfaceEventDeclarationWithNew original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "new"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.InterfaceEventDeclaration
interfaceEventDeclarationWithType :: Typed.TypedTerm Syntax.InterfaceEventDeclaration -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.InterfaceEventDeclaration
interfaceEventDeclarationWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "new"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"),
              Model.projectionFieldName = (Model.Name "new")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceEventDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.InterfaceIndexerDeclaration
interfaceIndexerDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Bool -> Typed.TypedTerm (Maybe Syntax.RefKind) -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.FormalParameterList -> Typed.TypedTerm Syntax.InterfaceAccessors -> Typed.TypedTerm Syntax.InterfaceIndexerDeclaration
interfaceIndexerDeclaration attributes new refKind type_ parameters accessors =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "new"),
          Model.fieldTerm = (Typed.unTypedTerm new)},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Typed.unTypedTerm refKind)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm parameters)},
        Model.Field {
          Model.fieldName = (Model.Name "accessors"),
          Model.fieldTerm = (Typed.unTypedTerm accessors)}]}))

-- | DSL accessor for the accessors field of hydra.ext.csharp.syntax.InterfaceIndexerDeclaration
interfaceIndexerDeclarationAccessors :: Typed.TypedTerm Syntax.InterfaceIndexerDeclaration -> Typed.TypedTerm Syntax.InterfaceAccessors
interfaceIndexerDeclarationAccessors x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
        Model.projectionFieldName = (Model.Name "accessors")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.InterfaceIndexerDeclaration
interfaceIndexerDeclarationAttributes :: Typed.TypedTerm Syntax.InterfaceIndexerDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes)
interfaceIndexerDeclarationAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.InterfaceIndexerDeclaration
interfaceIndexerDeclarationInterfaceIndexerDeclaration :: Typed.TypedName Syntax.InterfaceIndexerDeclaration
interfaceIndexerDeclarationInterfaceIndexerDeclaration =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration")

-- | DSL accessor for the new field of hydra.ext.csharp.syntax.InterfaceIndexerDeclaration
interfaceIndexerDeclarationNew :: Typed.TypedTerm Syntax.InterfaceIndexerDeclaration -> Typed.TypedTerm Bool
interfaceIndexerDeclarationNew x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
        Model.projectionFieldName = (Model.Name "new")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the parameters field of hydra.ext.csharp.syntax.InterfaceIndexerDeclaration
interfaceIndexerDeclarationParameters :: Typed.TypedTerm Syntax.InterfaceIndexerDeclaration -> Typed.TypedTerm Syntax.FormalParameterList
interfaceIndexerDeclarationParameters x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
        Model.projectionFieldName = (Model.Name "parameters")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the refKind field of hydra.ext.csharp.syntax.InterfaceIndexerDeclaration
interfaceIndexerDeclarationRefKind :: Typed.TypedTerm Syntax.InterfaceIndexerDeclaration -> Typed.TypedTerm (Maybe Syntax.RefKind)
interfaceIndexerDeclarationRefKind x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
        Model.projectionFieldName = (Model.Name "refKind")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.InterfaceIndexerDeclaration
interfaceIndexerDeclarationType :: Typed.TypedTerm Syntax.InterfaceIndexerDeclaration -> Typed.TypedTerm Syntax.Type
interfaceIndexerDeclarationType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the accessors field of hydra.ext.csharp.syntax.InterfaceIndexerDeclaration
interfaceIndexerDeclarationWithAccessors :: Typed.TypedTerm Syntax.InterfaceIndexerDeclaration -> Typed.TypedTerm Syntax.InterfaceAccessors -> Typed.TypedTerm Syntax.InterfaceIndexerDeclaration
interfaceIndexerDeclarationWithAccessors original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "new"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "new")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "accessors"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.InterfaceIndexerDeclaration
interfaceIndexerDeclarationWithAttributes :: Typed.TypedTerm Syntax.InterfaceIndexerDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.InterfaceIndexerDeclaration
interfaceIndexerDeclarationWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "new"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "new")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "accessors"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "accessors")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the new field of hydra.ext.csharp.syntax.InterfaceIndexerDeclaration
interfaceIndexerDeclarationWithNew :: Typed.TypedTerm Syntax.InterfaceIndexerDeclaration -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.InterfaceIndexerDeclaration
interfaceIndexerDeclarationWithNew original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "new"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "accessors"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "accessors")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the parameters field of hydra.ext.csharp.syntax.InterfaceIndexerDeclaration
interfaceIndexerDeclarationWithParameters :: Typed.TypedTerm Syntax.InterfaceIndexerDeclaration -> Typed.TypedTerm Syntax.FormalParameterList -> Typed.TypedTerm Syntax.InterfaceIndexerDeclaration
interfaceIndexerDeclarationWithParameters original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "new"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "new")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "accessors"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "accessors")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the refKind field of hydra.ext.csharp.syntax.InterfaceIndexerDeclaration
interfaceIndexerDeclarationWithRefKind :: Typed.TypedTerm Syntax.InterfaceIndexerDeclaration -> Typed.TypedTerm (Maybe Syntax.RefKind) -> Typed.TypedTerm Syntax.InterfaceIndexerDeclaration
interfaceIndexerDeclarationWithRefKind original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "new"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "new")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "accessors"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "accessors")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.InterfaceIndexerDeclaration
interfaceIndexerDeclarationWithType :: Typed.TypedTerm Syntax.InterfaceIndexerDeclaration -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.InterfaceIndexerDeclaration
interfaceIndexerDeclarationWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "new"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "new")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "accessors"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "accessors")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the event variant of hydra.ext.csharp.syntax.InterfaceMemberDeclaration
interfaceMemberDeclarationEvent :: Typed.TypedTerm Syntax.InterfaceEventDeclaration -> Typed.TypedTerm Syntax.InterfaceMemberDeclaration
interfaceMemberDeclarationEvent x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "event"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the indexer variant of hydra.ext.csharp.syntax.InterfaceMemberDeclaration
interfaceMemberDeclarationIndexer :: Typed.TypedTerm Syntax.InterfaceIndexerDeclaration -> Typed.TypedTerm Syntax.InterfaceMemberDeclaration
interfaceMemberDeclarationIndexer x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "indexer"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.InterfaceMemberDeclaration
interfaceMemberDeclarationInterfaceMemberDeclaration :: Typed.TypedName Syntax.InterfaceMemberDeclaration
interfaceMemberDeclarationInterfaceMemberDeclaration =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InterfaceMemberDeclaration")

-- | DSL injection for the method variant of hydra.ext.csharp.syntax.InterfaceMemberDeclaration
interfaceMemberDeclarationMethod :: Typed.TypedTerm Syntax.InterfaceMethodDeclaration -> Typed.TypedTerm Syntax.InterfaceMemberDeclaration
interfaceMemberDeclarationMethod x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "method"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the property variant of hydra.ext.csharp.syntax.InterfaceMemberDeclaration
interfaceMemberDeclarationProperty :: Typed.TypedTerm Syntax.InterfacePropertyDeclaration -> Typed.TypedTerm Syntax.InterfaceMemberDeclaration
interfaceMemberDeclarationProperty x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "property"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.csharp.syntax.InterfaceMethodDeclaration
interfaceMethodDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.ReturnType -> Typed.TypedTerm (Maybe Syntax.RefKind) -> Typed.TypedTerm Syntax.InterfaceMethodHeader -> Typed.TypedTerm Syntax.InterfaceMethodDeclaration
interfaceMethodDeclaration attributes new returnType refKind header =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "new"),
          Model.fieldTerm = (Typed.unTypedTerm new)},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Typed.unTypedTerm returnType)},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Typed.unTypedTerm refKind)},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Typed.unTypedTerm header)}]}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.InterfaceMethodDeclaration
interfaceMethodDeclarationAttributes :: Typed.TypedTerm Syntax.InterfaceMethodDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes)
interfaceMethodDeclarationAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the header field of hydra.ext.csharp.syntax.InterfaceMethodDeclaration
interfaceMethodDeclarationHeader :: Typed.TypedTerm Syntax.InterfaceMethodDeclaration -> Typed.TypedTerm Syntax.InterfaceMethodHeader
interfaceMethodDeclarationHeader x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"),
        Model.projectionFieldName = (Model.Name "header")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.InterfaceMethodDeclaration
interfaceMethodDeclarationInterfaceMethodDeclaration :: Typed.TypedName Syntax.InterfaceMethodDeclaration
interfaceMethodDeclarationInterfaceMethodDeclaration =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration")

-- | DSL accessor for the new field of hydra.ext.csharp.syntax.InterfaceMethodDeclaration
interfaceMethodDeclarationNew :: Typed.TypedTerm Syntax.InterfaceMethodDeclaration -> Typed.TypedTerm Bool
interfaceMethodDeclarationNew x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"),
        Model.projectionFieldName = (Model.Name "new")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the refKind field of hydra.ext.csharp.syntax.InterfaceMethodDeclaration
interfaceMethodDeclarationRefKind :: Typed.TypedTerm Syntax.InterfaceMethodDeclaration -> Typed.TypedTerm (Maybe Syntax.RefKind)
interfaceMethodDeclarationRefKind x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"),
        Model.projectionFieldName = (Model.Name "refKind")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the returnType field of hydra.ext.csharp.syntax.InterfaceMethodDeclaration
interfaceMethodDeclarationReturnType :: Typed.TypedTerm Syntax.InterfaceMethodDeclaration -> Typed.TypedTerm Syntax.ReturnType
interfaceMethodDeclarationReturnType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"),
        Model.projectionFieldName = (Model.Name "returnType")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.InterfaceMethodDeclaration
interfaceMethodDeclarationWithAttributes :: Typed.TypedTerm Syntax.InterfaceMethodDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.InterfaceMethodDeclaration
interfaceMethodDeclarationWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "new"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "new")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "header")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the header field of hydra.ext.csharp.syntax.InterfaceMethodDeclaration
interfaceMethodDeclarationWithHeader :: Typed.TypedTerm Syntax.InterfaceMethodDeclaration -> Typed.TypedTerm Syntax.InterfaceMethodHeader -> Typed.TypedTerm Syntax.InterfaceMethodDeclaration
interfaceMethodDeclarationWithHeader original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "new"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "new")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the new field of hydra.ext.csharp.syntax.InterfaceMethodDeclaration
interfaceMethodDeclarationWithNew :: Typed.TypedTerm Syntax.InterfaceMethodDeclaration -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.InterfaceMethodDeclaration
interfaceMethodDeclarationWithNew original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "new"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "header")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the refKind field of hydra.ext.csharp.syntax.InterfaceMethodDeclaration
interfaceMethodDeclarationWithRefKind :: Typed.TypedTerm Syntax.InterfaceMethodDeclaration -> Typed.TypedTerm (Maybe Syntax.RefKind) -> Typed.TypedTerm Syntax.InterfaceMethodDeclaration
interfaceMethodDeclarationWithRefKind original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "new"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "new")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "header")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the returnType field of hydra.ext.csharp.syntax.InterfaceMethodDeclaration
interfaceMethodDeclarationWithReturnType :: Typed.TypedTerm Syntax.InterfaceMethodDeclaration -> Typed.TypedTerm Syntax.ReturnType -> Typed.TypedTerm Syntax.InterfaceMethodDeclaration
interfaceMethodDeclarationWithReturnType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "new"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "new")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "header")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.InterfaceMethodHeader
interfaceMethodHeader :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.FormalParameterList) -> Typed.TypedTerm (Maybe Syntax.TypeParameterList) -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] -> Typed.TypedTerm Syntax.InterfaceMethodHeader
interfaceMethodHeader name parameters typeParameters constraints =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm parameters)},
        Model.Field {
          Model.fieldName = (Model.Name "typeParameters"),
          Model.fieldTerm = (Typed.unTypedTerm typeParameters)},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Typed.unTypedTerm constraints)}]}))

-- | DSL accessor for the constraints field of hydra.ext.csharp.syntax.InterfaceMethodHeader
interfaceMethodHeaderConstraints :: Typed.TypedTerm Syntax.InterfaceMethodHeader -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause]
interfaceMethodHeaderConstraints x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"),
        Model.projectionFieldName = (Model.Name "constraints")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.InterfaceMethodHeader
interfaceMethodHeaderInterfaceMethodHeader :: Typed.TypedName Syntax.InterfaceMethodHeader
interfaceMethodHeaderInterfaceMethodHeader = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader")

-- | DSL accessor for the name field of hydra.ext.csharp.syntax.InterfaceMethodHeader
interfaceMethodHeaderName :: Typed.TypedTerm Syntax.InterfaceMethodHeader -> Typed.TypedTerm Syntax.Identifier
interfaceMethodHeaderName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the parameters field of hydra.ext.csharp.syntax.InterfaceMethodHeader
interfaceMethodHeaderParameters :: Typed.TypedTerm Syntax.InterfaceMethodHeader -> Typed.TypedTerm (Maybe Syntax.FormalParameterList)
interfaceMethodHeaderParameters x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"),
        Model.projectionFieldName = (Model.Name "parameters")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the typeParameters field of hydra.ext.csharp.syntax.InterfaceMethodHeader
interfaceMethodHeaderTypeParameters :: Typed.TypedTerm Syntax.InterfaceMethodHeader -> Typed.TypedTerm (Maybe Syntax.TypeParameterList)
interfaceMethodHeaderTypeParameters x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"),
        Model.projectionFieldName = (Model.Name "typeParameters")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the constraints field of hydra.ext.csharp.syntax.InterfaceMethodHeader
interfaceMethodHeaderWithConstraints :: Typed.TypedTerm Syntax.InterfaceMethodHeader -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] -> Typed.TypedTerm Syntax.InterfaceMethodHeader
interfaceMethodHeaderWithConstraints original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeParameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"),
              Model.projectionFieldName = (Model.Name "typeParameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the name field of hydra.ext.csharp.syntax.InterfaceMethodHeader
interfaceMethodHeaderWithName :: Typed.TypedTerm Syntax.InterfaceMethodHeader -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.InterfaceMethodHeader
interfaceMethodHeaderWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeParameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"),
              Model.projectionFieldName = (Model.Name "typeParameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the parameters field of hydra.ext.csharp.syntax.InterfaceMethodHeader
interfaceMethodHeaderWithParameters :: Typed.TypedTerm Syntax.InterfaceMethodHeader -> Typed.TypedTerm (Maybe Syntax.FormalParameterList) -> Typed.TypedTerm Syntax.InterfaceMethodHeader
interfaceMethodHeaderWithParameters original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "typeParameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"),
              Model.projectionFieldName = (Model.Name "typeParameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the typeParameters field of hydra.ext.csharp.syntax.InterfaceMethodHeader
interfaceMethodHeaderWithTypeParameters :: Typed.TypedTerm Syntax.InterfaceMethodHeader -> Typed.TypedTerm (Maybe Syntax.TypeParameterList) -> Typed.TypedTerm Syntax.InterfaceMethodHeader
interfaceMethodHeaderWithTypeParameters original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeParameters"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceMethodHeader"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL name token for hydra.ext.csharp.syntax.InterfaceModifier
interfaceModifierInterfaceModifier :: Typed.TypedName Syntax.InterfaceModifier
interfaceModifierInterfaceModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InterfaceModifier")

-- | DSL injection for the internal variant of hydra.ext.csharp.syntax.InterfaceModifier
interfaceModifierInternal :: Typed.TypedTerm Syntax.InterfaceModifier
interfaceModifierInternal =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "internal"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the new variant of hydra.ext.csharp.syntax.InterfaceModifier
interfaceModifierNew :: Typed.TypedTerm Syntax.InterfaceModifier
interfaceModifierNew =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "new"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the private variant of hydra.ext.csharp.syntax.InterfaceModifier
interfaceModifierPrivate :: Typed.TypedTerm Syntax.InterfaceModifier
interfaceModifierPrivate =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "private"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the protected variant of hydra.ext.csharp.syntax.InterfaceModifier
interfaceModifierProtected :: Typed.TypedTerm Syntax.InterfaceModifier
interfaceModifierProtected =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "protected"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the public variant of hydra.ext.csharp.syntax.InterfaceModifier
interfaceModifierPublic :: Typed.TypedTerm Syntax.InterfaceModifier
interfaceModifierPublic =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "public"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the unsafe variant of hydra.ext.csharp.syntax.InterfaceModifier
interfaceModifierUnsafe :: Typed.TypedTerm Syntax.InterfaceModifier
interfaceModifierUnsafe =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "unsafe"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL constructor for hydra.ext.csharp.syntax.InterfacePropertyDeclaration
interfacePropertyDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Bool -> Typed.TypedTerm (Maybe Syntax.RefKind) -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.InterfaceAccessors -> Typed.TypedTerm Syntax.InterfacePropertyDeclaration
interfacePropertyDeclaration attributes new refKind type_ name accessors =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "new"),
          Model.fieldTerm = (Typed.unTypedTerm new)},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Typed.unTypedTerm refKind)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "accessors"),
          Model.fieldTerm = (Typed.unTypedTerm accessors)}]}))

-- | DSL accessor for the accessors field of hydra.ext.csharp.syntax.InterfacePropertyDeclaration
interfacePropertyDeclarationAccessors :: Typed.TypedTerm Syntax.InterfacePropertyDeclaration -> Typed.TypedTerm Syntax.InterfaceAccessors
interfacePropertyDeclarationAccessors x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
        Model.projectionFieldName = (Model.Name "accessors")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.InterfacePropertyDeclaration
interfacePropertyDeclarationAttributes :: Typed.TypedTerm Syntax.InterfacePropertyDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes)
interfacePropertyDeclarationAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.InterfacePropertyDeclaration
interfacePropertyDeclarationInterfacePropertyDeclaration :: Typed.TypedName Syntax.InterfacePropertyDeclaration
interfacePropertyDeclarationInterfacePropertyDeclaration =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration")

-- | DSL accessor for the name field of hydra.ext.csharp.syntax.InterfacePropertyDeclaration
interfacePropertyDeclarationName :: Typed.TypedTerm Syntax.InterfacePropertyDeclaration -> Typed.TypedTerm Syntax.Identifier
interfacePropertyDeclarationName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the new field of hydra.ext.csharp.syntax.InterfacePropertyDeclaration
interfacePropertyDeclarationNew :: Typed.TypedTerm Syntax.InterfacePropertyDeclaration -> Typed.TypedTerm Bool
interfacePropertyDeclarationNew x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
        Model.projectionFieldName = (Model.Name "new")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the refKind field of hydra.ext.csharp.syntax.InterfacePropertyDeclaration
interfacePropertyDeclarationRefKind :: Typed.TypedTerm Syntax.InterfacePropertyDeclaration -> Typed.TypedTerm (Maybe Syntax.RefKind)
interfacePropertyDeclarationRefKind x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
        Model.projectionFieldName = (Model.Name "refKind")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.InterfacePropertyDeclaration
interfacePropertyDeclarationType :: Typed.TypedTerm Syntax.InterfacePropertyDeclaration -> Typed.TypedTerm Syntax.Type
interfacePropertyDeclarationType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the accessors field of hydra.ext.csharp.syntax.InterfacePropertyDeclaration
interfacePropertyDeclarationWithAccessors :: Typed.TypedTerm Syntax.InterfacePropertyDeclaration -> Typed.TypedTerm Syntax.InterfaceAccessors -> Typed.TypedTerm Syntax.InterfacePropertyDeclaration
interfacePropertyDeclarationWithAccessors original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "new"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "new")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "accessors"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.InterfacePropertyDeclaration
interfacePropertyDeclarationWithAttributes :: Typed.TypedTerm Syntax.InterfacePropertyDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.InterfacePropertyDeclaration
interfacePropertyDeclarationWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "new"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "new")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "accessors"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "accessors")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.csharp.syntax.InterfacePropertyDeclaration
interfacePropertyDeclarationWithName :: Typed.TypedTerm Syntax.InterfacePropertyDeclaration -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.InterfacePropertyDeclaration
interfacePropertyDeclarationWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "new"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "new")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "accessors"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "accessors")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the new field of hydra.ext.csharp.syntax.InterfacePropertyDeclaration
interfacePropertyDeclarationWithNew :: Typed.TypedTerm Syntax.InterfacePropertyDeclaration -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.InterfacePropertyDeclaration
interfacePropertyDeclarationWithNew original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "new"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "accessors"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "accessors")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the refKind field of hydra.ext.csharp.syntax.InterfacePropertyDeclaration
interfacePropertyDeclarationWithRefKind :: Typed.TypedTerm Syntax.InterfacePropertyDeclaration -> Typed.TypedTerm (Maybe Syntax.RefKind) -> Typed.TypedTerm Syntax.InterfacePropertyDeclaration
interfacePropertyDeclarationWithRefKind original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "new"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "new")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "accessors"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "accessors")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.InterfacePropertyDeclaration
interfacePropertyDeclarationWithType :: Typed.TypedTerm Syntax.InterfacePropertyDeclaration -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.InterfacePropertyDeclaration
interfacePropertyDeclarationWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "new"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "new")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "accessors"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfacePropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "accessors")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for the hydra.ext.csharp.syntax.InterfaceType wrapper
interfaceType :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.InterfaceType
interfaceType x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.InterfaceType"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.InterfaceType
interfaceTypeInterfaceType :: Typed.TypedName Syntax.InterfaceType
interfaceTypeInterfaceType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InterfaceType")

-- | DSL constructor for the hydra.ext.csharp.syntax.InterpolatedRegularStringExpression wrapper
interpolatedRegularStringExpression :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.InterpolatedRegularStringExpression
interpolatedRegularStringExpression x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.InterpolatedRegularStringExpression"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.InterpolatedRegularStringExpression
interpolatedRegularStringExpressionInterpolatedRegularStringExpression :: Typed.TypedName Syntax.InterpolatedRegularStringExpression
interpolatedRegularStringExpressionInterpolatedRegularStringExpression =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InterpolatedRegularStringExpression")

-- | DSL name token for hydra.ext.csharp.syntax.InterpolatedStringExpression
interpolatedStringExpressionInterpolatedStringExpression :: Typed.TypedName Syntax.InterpolatedStringExpression
interpolatedStringExpressionInterpolatedStringExpression =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InterpolatedStringExpression")

-- | DSL injection for the regular variant of hydra.ext.csharp.syntax.InterpolatedStringExpression
interpolatedStringExpressionRegular :: Typed.TypedTerm Syntax.InterpolatedRegularStringExpression -> Typed.TypedTerm Syntax.InterpolatedStringExpression
interpolatedStringExpressionRegular x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterpolatedStringExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "regular"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the verbatim variant of hydra.ext.csharp.syntax.InterpolatedStringExpression
interpolatedStringExpressionVerbatim :: Typed.TypedTerm Syntax.InterpolatedVerbatimStringExpression -> Typed.TypedTerm Syntax.InterpolatedStringExpression
interpolatedStringExpressionVerbatim x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InterpolatedStringExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "verbatim"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for the hydra.ext.csharp.syntax.InterpolatedVerbatimStringExpression wrapper
interpolatedVerbatimStringExpression :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.InterpolatedVerbatimStringExpression
interpolatedVerbatimStringExpression x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.InterpolatedVerbatimStringExpression"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.InterpolatedVerbatimStringExpression
interpolatedVerbatimStringExpressionInterpolatedVerbatimStringExpression :: Typed.TypedName Syntax.InterpolatedVerbatimStringExpression
interpolatedVerbatimStringExpressionInterpolatedVerbatimStringExpression =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InterpolatedVerbatimStringExpression")

-- | DSL constructor for hydra.ext.csharp.syntax.InvocationExpression
invocationExpression :: Typed.TypedTerm Syntax.PrimaryExpression -> Typed.TypedTerm (Maybe Syntax.ArgumentList) -> Typed.TypedTerm Syntax.InvocationExpression
invocationExpression expression arguments =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InvocationExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm expression)},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Typed.unTypedTerm arguments)}]}))

-- | DSL accessor for the arguments field of hydra.ext.csharp.syntax.InvocationExpression
invocationExpressionArguments :: Typed.TypedTerm Syntax.InvocationExpression -> Typed.TypedTerm (Maybe Syntax.ArgumentList)
invocationExpressionArguments x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InvocationExpression"),
        Model.projectionFieldName = (Model.Name "arguments")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.InvocationExpression
invocationExpressionExpression :: Typed.TypedTerm Syntax.InvocationExpression -> Typed.TypedTerm Syntax.PrimaryExpression
invocationExpressionExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InvocationExpression"),
        Model.projectionFieldName = (Model.Name "expression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.InvocationExpression
invocationExpressionInvocationExpression :: Typed.TypedName Syntax.InvocationExpression
invocationExpressionInvocationExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.InvocationExpression")

-- | DSL updater for the arguments field of hydra.ext.csharp.syntax.InvocationExpression
invocationExpressionWithArguments :: Typed.TypedTerm Syntax.InvocationExpression -> Typed.TypedTerm (Maybe Syntax.ArgumentList) -> Typed.TypedTerm Syntax.InvocationExpression
invocationExpressionWithArguments original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InvocationExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InvocationExpression"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the expression field of hydra.ext.csharp.syntax.InvocationExpression
invocationExpressionWithExpression :: Typed.TypedTerm Syntax.InvocationExpression -> Typed.TypedTerm Syntax.PrimaryExpression -> Typed.TypedTerm Syntax.InvocationExpression
invocationExpressionWithExpression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.InvocationExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.InvocationExpression"),
              Model.projectionFieldName = (Model.Name "arguments")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.IsPatternExpression
isPatternExpression :: Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.IsPatternExpression
isPatternExpression expression pattern =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IsPatternExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm expression)},
        Model.Field {
          Model.fieldName = (Model.Name "pattern"),
          Model.fieldTerm = (Typed.unTypedTerm pattern)}]}))

-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.IsPatternExpression
isPatternExpressionExpression :: Typed.TypedTerm Syntax.IsPatternExpression -> Typed.TypedTerm Syntax.RelationalExpression
isPatternExpressionExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IsPatternExpression"),
        Model.projectionFieldName = (Model.Name "expression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.IsPatternExpression
isPatternExpressionIsPatternExpression :: Typed.TypedName Syntax.IsPatternExpression
isPatternExpressionIsPatternExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.IsPatternExpression")

-- | DSL accessor for the pattern field of hydra.ext.csharp.syntax.IsPatternExpression
isPatternExpressionPattern :: Typed.TypedTerm Syntax.IsPatternExpression -> Typed.TypedTerm Syntax.Pattern
isPatternExpressionPattern x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IsPatternExpression"),
        Model.projectionFieldName = (Model.Name "pattern")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the expression field of hydra.ext.csharp.syntax.IsPatternExpression
isPatternExpressionWithExpression :: Typed.TypedTerm Syntax.IsPatternExpression -> Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.IsPatternExpression
isPatternExpressionWithExpression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IsPatternExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "pattern"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IsPatternExpression"),
              Model.projectionFieldName = (Model.Name "pattern")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the pattern field of hydra.ext.csharp.syntax.IsPatternExpression
isPatternExpressionWithPattern :: Typed.TypedTerm Syntax.IsPatternExpression -> Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.IsPatternExpression
isPatternExpressionWithPattern original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IsPatternExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IsPatternExpression"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "pattern"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.IsTypeExpression
isTypeExpression :: Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.IsTypeExpression
isTypeExpression expression type_ =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IsTypeExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm expression)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)}]}))

-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.IsTypeExpression
isTypeExpressionExpression :: Typed.TypedTerm Syntax.IsTypeExpression -> Typed.TypedTerm Syntax.RelationalExpression
isTypeExpressionExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IsTypeExpression"),
        Model.projectionFieldName = (Model.Name "expression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.IsTypeExpression
isTypeExpressionIsTypeExpression :: Typed.TypedName Syntax.IsTypeExpression
isTypeExpressionIsTypeExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.IsTypeExpression")

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.IsTypeExpression
isTypeExpressionType :: Typed.TypedTerm Syntax.IsTypeExpression -> Typed.TypedTerm Syntax.Type
isTypeExpressionType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IsTypeExpression"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the expression field of hydra.ext.csharp.syntax.IsTypeExpression
isTypeExpressionWithExpression :: Typed.TypedTerm Syntax.IsTypeExpression -> Typed.TypedTerm Syntax.RelationalExpression -> Typed.TypedTerm Syntax.IsTypeExpression
isTypeExpressionWithExpression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IsTypeExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IsTypeExpression"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.IsTypeExpression
isTypeExpressionWithType :: Typed.TypedTerm Syntax.IsTypeExpression -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.IsTypeExpression
isTypeExpressionWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.IsTypeExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IsTypeExpression"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the do variant of hydra.ext.csharp.syntax.IterationStatement
iterationStatementDo :: Typed.TypedTerm Syntax.DoStatement -> Typed.TypedTerm Syntax.IterationStatement
iterationStatementDo x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IterationStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "do"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the for variant of hydra.ext.csharp.syntax.IterationStatement
iterationStatementFor :: Typed.TypedTerm Syntax.ForStatement -> Typed.TypedTerm Syntax.IterationStatement
iterationStatementFor x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IterationStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "for"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the foreach variant of hydra.ext.csharp.syntax.IterationStatement
iterationStatementForeach :: Typed.TypedTerm Syntax.ForeachStatement -> Typed.TypedTerm Syntax.IterationStatement
iterationStatementForeach x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IterationStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "foreach"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.IterationStatement
iterationStatementIterationStatement :: Typed.TypedName Syntax.IterationStatement
iterationStatementIterationStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.IterationStatement")

-- | DSL injection for the while variant of hydra.ext.csharp.syntax.IterationStatement
iterationStatementWhile :: Typed.TypedTerm Syntax.WhileStatement -> Typed.TypedTerm Syntax.IterationStatement
iterationStatementWhile x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.IterationStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "while"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.csharp.syntax.JoinClause
joinClause :: Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.JoinClause
joinClause type_ identifier in_ on equals into =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm identifier)},
        Model.Field {
          Model.fieldName = (Model.Name "in"),
          Model.fieldTerm = (Typed.unTypedTerm in_)},
        Model.Field {
          Model.fieldName = (Model.Name "on"),
          Model.fieldTerm = (Typed.unTypedTerm on)},
        Model.Field {
          Model.fieldName = (Model.Name "equals"),
          Model.fieldTerm = (Typed.unTypedTerm equals)},
        Model.Field {
          Model.fieldName = (Model.Name "into"),
          Model.fieldTerm = (Typed.unTypedTerm into)}]}))

-- | DSL accessor for the equals field of hydra.ext.csharp.syntax.JoinClause
joinClauseEquals :: Typed.TypedTerm Syntax.JoinClause -> Typed.TypedTerm Syntax.Expression
joinClauseEquals x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
        Model.projectionFieldName = (Model.Name "equals")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.JoinClause
joinClauseIdentifier :: Typed.TypedTerm Syntax.JoinClause -> Typed.TypedTerm Syntax.Identifier
joinClauseIdentifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
        Model.projectionFieldName = (Model.Name "identifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the in field of hydra.ext.csharp.syntax.JoinClause
joinClauseIn :: Typed.TypedTerm Syntax.JoinClause -> Typed.TypedTerm Syntax.Expression
joinClauseIn x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
        Model.projectionFieldName = (Model.Name "in")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the into field of hydra.ext.csharp.syntax.JoinClause
joinClauseInto :: Typed.TypedTerm Syntax.JoinClause -> Typed.TypedTerm (Maybe Syntax.Identifier)
joinClauseInto x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
        Model.projectionFieldName = (Model.Name "into")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.JoinClause
joinClauseJoinClause :: Typed.TypedName Syntax.JoinClause
joinClauseJoinClause = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.JoinClause")

-- | DSL accessor for the on field of hydra.ext.csharp.syntax.JoinClause
joinClauseOn :: Typed.TypedTerm Syntax.JoinClause -> Typed.TypedTerm Syntax.Expression
joinClauseOn x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
        Model.projectionFieldName = (Model.Name "on")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.JoinClause
joinClauseType :: Typed.TypedTerm Syntax.JoinClause -> Typed.TypedTerm (Maybe Syntax.Type)
joinClauseType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the equals field of hydra.ext.csharp.syntax.JoinClause
joinClauseWithEquals :: Typed.TypedTerm Syntax.JoinClause -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.JoinClause
joinClauseWithEquals original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "in"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
              Model.projectionFieldName = (Model.Name "in")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "on"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
              Model.projectionFieldName = (Model.Name "on")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "equals"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "into"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
              Model.projectionFieldName = (Model.Name "into")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.JoinClause
joinClauseWithIdentifier :: Typed.TypedTerm Syntax.JoinClause -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.JoinClause
joinClauseWithIdentifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "in"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
              Model.projectionFieldName = (Model.Name "in")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "on"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
              Model.projectionFieldName = (Model.Name "on")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "equals"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
              Model.projectionFieldName = (Model.Name "equals")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "into"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
              Model.projectionFieldName = (Model.Name "into")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the in field of hydra.ext.csharp.syntax.JoinClause
joinClauseWithIn :: Typed.TypedTerm Syntax.JoinClause -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.JoinClause
joinClauseWithIn original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "in"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "on"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
              Model.projectionFieldName = (Model.Name "on")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "equals"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
              Model.projectionFieldName = (Model.Name "equals")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "into"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
              Model.projectionFieldName = (Model.Name "into")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the into field of hydra.ext.csharp.syntax.JoinClause
joinClauseWithInto :: Typed.TypedTerm Syntax.JoinClause -> Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.JoinClause
joinClauseWithInto original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "in"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
              Model.projectionFieldName = (Model.Name "in")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "on"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
              Model.projectionFieldName = (Model.Name "on")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "equals"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
              Model.projectionFieldName = (Model.Name "equals")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "into"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the on field of hydra.ext.csharp.syntax.JoinClause
joinClauseWithOn :: Typed.TypedTerm Syntax.JoinClause -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.JoinClause
joinClauseWithOn original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "in"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
              Model.projectionFieldName = (Model.Name "in")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "on"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "equals"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
              Model.projectionFieldName = (Model.Name "equals")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "into"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
              Model.projectionFieldName = (Model.Name "into")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.JoinClause
joinClauseWithType :: Typed.TypedTerm Syntax.JoinClause -> Typed.TypedTerm (Maybe Syntax.Type) -> Typed.TypedTerm Syntax.JoinClause
joinClauseWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "in"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
              Model.projectionFieldName = (Model.Name "in")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "on"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
              Model.projectionFieldName = (Model.Name "on")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "equals"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
              Model.projectionFieldName = (Model.Name "equals")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "into"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JoinClause"),
              Model.projectionFieldName = (Model.Name "into")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the break variant of hydra.ext.csharp.syntax.JumpStatement
jumpStatementBreak :: Typed.TypedTerm Syntax.JumpStatement
jumpStatementBreak =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JumpStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "break"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the continue variant of hydra.ext.csharp.syntax.JumpStatement
jumpStatementContinue :: Typed.TypedTerm Syntax.JumpStatement
jumpStatementContinue =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JumpStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "continue"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the goto variant of hydra.ext.csharp.syntax.JumpStatement
jumpStatementGoto :: Typed.TypedTerm Syntax.GotoStatement -> Typed.TypedTerm Syntax.JumpStatement
jumpStatementGoto x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JumpStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "goto"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.JumpStatement
jumpStatementJumpStatement :: Typed.TypedName Syntax.JumpStatement
jumpStatementJumpStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.JumpStatement")

-- | DSL injection for the return variant of hydra.ext.csharp.syntax.JumpStatement
jumpStatementReturn :: Typed.TypedTerm Syntax.ReturnStatement -> Typed.TypedTerm Syntax.JumpStatement
jumpStatementReturn x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JumpStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "return"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the throw variant of hydra.ext.csharp.syntax.JumpStatement
jumpStatementThrow :: Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.JumpStatement
jumpStatementThrow x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.JumpStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "throw"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for the hydra.ext.csharp.syntax.Keyword wrapper
keyword :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Keyword
keyword x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.Keyword"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.Keyword
keywordKeyword :: Typed.TypedName Syntax.Keyword
keywordKeyword = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.Keyword")

-- | DSL constructor for hydra.ext.csharp.syntax.LabeledStatement
labeledStatement :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.LabeledStatement
labeledStatement label statement =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LabeledStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "label"),
          Model.fieldTerm = (Typed.unTypedTerm label)},
        Model.Field {
          Model.fieldName = (Model.Name "statement"),
          Model.fieldTerm = (Typed.unTypedTerm statement)}]}))

-- | DSL accessor for the label field of hydra.ext.csharp.syntax.LabeledStatement
labeledStatementLabel :: Typed.TypedTerm Syntax.LabeledStatement -> Typed.TypedTerm Syntax.Identifier
labeledStatementLabel x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LabeledStatement"),
        Model.projectionFieldName = (Model.Name "label")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.LabeledStatement
labeledStatementLabeledStatement :: Typed.TypedName Syntax.LabeledStatement
labeledStatementLabeledStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.LabeledStatement")

-- | DSL accessor for the statement field of hydra.ext.csharp.syntax.LabeledStatement
labeledStatementStatement :: Typed.TypedTerm Syntax.LabeledStatement -> Typed.TypedTerm Syntax.Statement
labeledStatementStatement x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LabeledStatement"),
        Model.projectionFieldName = (Model.Name "statement")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the label field of hydra.ext.csharp.syntax.LabeledStatement
labeledStatementWithLabel :: Typed.TypedTerm Syntax.LabeledStatement -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.LabeledStatement
labeledStatementWithLabel original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LabeledStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "label"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "statement"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LabeledStatement"),
              Model.projectionFieldName = (Model.Name "statement")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the statement field of hydra.ext.csharp.syntax.LabeledStatement
labeledStatementWithStatement :: Typed.TypedTerm Syntax.LabeledStatement -> Typed.TypedTerm Syntax.Statement -> Typed.TypedTerm Syntax.LabeledStatement
labeledStatementWithStatement original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LabeledStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "label"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LabeledStatement"),
              Model.projectionFieldName = (Model.Name "label")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "statement"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.LambdaExpression
lambdaExpression :: Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.AnonymousFunctionSignature -> Typed.TypedTerm Syntax.AnonymousFunctionBody -> Typed.TypedTerm Syntax.LambdaExpression
lambdaExpression async signature body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LambdaExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "async"),
          Model.fieldTerm = (Typed.unTypedTerm async)},
        Model.Field {
          Model.fieldName = (Model.Name "signature"),
          Model.fieldTerm = (Typed.unTypedTerm signature)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the async field of hydra.ext.csharp.syntax.LambdaExpression
lambdaExpressionAsync :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Bool
lambdaExpressionAsync x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LambdaExpression"),
        Model.projectionFieldName = (Model.Name "async")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.LambdaExpression
lambdaExpressionBody :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.AnonymousFunctionBody
lambdaExpressionBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LambdaExpression"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.LambdaExpression
lambdaExpressionLambdaExpression :: Typed.TypedName Syntax.LambdaExpression
lambdaExpressionLambdaExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.LambdaExpression")

-- | DSL accessor for the signature field of hydra.ext.csharp.syntax.LambdaExpression
lambdaExpressionSignature :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.AnonymousFunctionSignature
lambdaExpressionSignature x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LambdaExpression"),
        Model.projectionFieldName = (Model.Name "signature")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the async field of hydra.ext.csharp.syntax.LambdaExpression
lambdaExpressionWithAsync :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.LambdaExpression
lambdaExpressionWithAsync original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LambdaExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "async"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "signature"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LambdaExpression"),
              Model.projectionFieldName = (Model.Name "signature")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LambdaExpression"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the body field of hydra.ext.csharp.syntax.LambdaExpression
lambdaExpressionWithBody :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.AnonymousFunctionBody -> Typed.TypedTerm Syntax.LambdaExpression
lambdaExpressionWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LambdaExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "async"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LambdaExpression"),
              Model.projectionFieldName = (Model.Name "async")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "signature"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LambdaExpression"),
              Model.projectionFieldName = (Model.Name "signature")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the signature field of hydra.ext.csharp.syntax.LambdaExpression
lambdaExpressionWithSignature :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.AnonymousFunctionSignature -> Typed.TypedTerm Syntax.LambdaExpression
lambdaExpressionWithSignature original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LambdaExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "async"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LambdaExpression"),
              Model.projectionFieldName = (Model.Name "async")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "signature"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LambdaExpression"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.LetClause
letClause :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.LetClause
letClause left right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LetClause"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

-- | DSL accessor for the left field of hydra.ext.csharp.syntax.LetClause
letClauseLeft :: Typed.TypedTerm Syntax.LetClause -> Typed.TypedTerm Syntax.Identifier
letClauseLeft x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LetClause"),
        Model.projectionFieldName = (Model.Name "left")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.LetClause
letClauseLetClause :: Typed.TypedName Syntax.LetClause
letClauseLetClause = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.LetClause")

-- | DSL accessor for the right field of hydra.ext.csharp.syntax.LetClause
letClauseRight :: Typed.TypedTerm Syntax.LetClause -> Typed.TypedTerm Syntax.Expression
letClauseRight x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LetClause"),
        Model.projectionFieldName = (Model.Name "right")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the left field of hydra.ext.csharp.syntax.LetClause
letClauseWithLeft :: Typed.TypedTerm Syntax.LetClause -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.LetClause
letClauseWithLeft original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LetClause"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LetClause"),
              Model.projectionFieldName = (Model.Name "right")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the right field of hydra.ext.csharp.syntax.LetClause
letClauseWithRight :: Typed.TypedTerm Syntax.LetClause -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.LetClause
letClauseWithRight original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LetClause"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LetClause"),
              Model.projectionFieldName = (Model.Name "left")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the boolean variant of hydra.ext.csharp.syntax.Literal
literalBoolean :: Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Literal
literalBoolean x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Literal"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "boolean"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the character variant of hydra.ext.csharp.syntax.Literal
literalCharacter :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Literal
literalCharacter x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Literal"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "character"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the integer variant of hydra.ext.csharp.syntax.Literal
literalInteger :: Typed.TypedTerm Syntax.IntegerLiteral -> Typed.TypedTerm Syntax.Literal
literalInteger x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Literal"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "integer"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.Literal
literalLiteral :: Typed.TypedName Syntax.Literal
literalLiteral = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.Literal")

-- | DSL injection for the null variant of hydra.ext.csharp.syntax.Literal
literalNull :: Typed.TypedTerm Syntax.Literal
literalNull =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Literal"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "null"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the real variant of hydra.ext.csharp.syntax.Literal
literalReal :: Typed.TypedTerm Double -> Typed.TypedTerm Syntax.Literal
literalReal x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Literal"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "real"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the string variant of hydra.ext.csharp.syntax.Literal
literalString :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Literal
literalString x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Literal"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "string"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.csharp.syntax.LocalConstantDeclaration
localConstantDeclaration :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm [Syntax.ConstantDeclarator] -> Typed.TypedTerm Syntax.LocalConstantDeclaration
localConstantDeclaration type_ declarators =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalConstantDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Typed.unTypedTerm declarators)}]}))

-- | DSL accessor for the declarators field of hydra.ext.csharp.syntax.LocalConstantDeclaration
localConstantDeclarationDeclarators :: Typed.TypedTerm Syntax.LocalConstantDeclaration -> Typed.TypedTerm [Syntax.ConstantDeclarator]
localConstantDeclarationDeclarators x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalConstantDeclaration"),
        Model.projectionFieldName = (Model.Name "declarators")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.LocalConstantDeclaration
localConstantDeclarationLocalConstantDeclaration :: Typed.TypedName Syntax.LocalConstantDeclaration
localConstantDeclarationLocalConstantDeclaration =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.LocalConstantDeclaration")

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.LocalConstantDeclaration
localConstantDeclarationType :: Typed.TypedTerm Syntax.LocalConstantDeclaration -> Typed.TypedTerm Syntax.Type
localConstantDeclarationType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalConstantDeclaration"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the declarators field of hydra.ext.csharp.syntax.LocalConstantDeclaration
localConstantDeclarationWithDeclarators :: Typed.TypedTerm Syntax.LocalConstantDeclaration -> Typed.TypedTerm [Syntax.ConstantDeclarator] -> Typed.TypedTerm Syntax.LocalConstantDeclaration
localConstantDeclarationWithDeclarators original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalConstantDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalConstantDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.LocalConstantDeclaration
localConstantDeclarationWithType :: Typed.TypedTerm Syntax.LocalConstantDeclaration -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.LocalConstantDeclaration
localConstantDeclarationWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalConstantDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalConstantDeclaration"),
              Model.projectionFieldName = (Model.Name "declarators")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the block variant of hydra.ext.csharp.syntax.LocalFunctionBody
localFunctionBodyBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.LocalFunctionBody
localFunctionBodyBlock x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "block"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.LocalFunctionBody
localFunctionBodyExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.LocalFunctionBody
localFunctionBodyExpression x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "expression"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.LocalFunctionBody
localFunctionBodyLocalFunctionBody :: Typed.TypedName Syntax.LocalFunctionBody
localFunctionBodyLocalFunctionBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.LocalFunctionBody")

-- | DSL injection for the nullConditionalInvocation variant of hydra.ext.csharp.syntax.LocalFunctionBody
localFunctionBodyNullConditionalInvocation :: Typed.TypedTerm Syntax.NullConditionalInvocationExpression -> Typed.TypedTerm Syntax.LocalFunctionBody
localFunctionBodyNullConditionalInvocation x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "nullConditionalInvocation"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.LocalFunctionDeclaration
localFunctionDeclarationLocalFunctionDeclaration :: Typed.TypedName Syntax.LocalFunctionDeclaration
localFunctionDeclarationLocalFunctionDeclaration =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.LocalFunctionDeclaration")

-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.LocalFunctionDeclaration
localFunctionDeclarationRef :: Typed.TypedTerm Syntax.RefLocalFunctionDeclaration -> Typed.TypedTerm Syntax.LocalFunctionDeclaration
localFunctionDeclarationRef x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "ref"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the standard variant of hydra.ext.csharp.syntax.LocalFunctionDeclaration
localFunctionDeclarationStandard :: Typed.TypedTerm Syntax.StandardLocalFunctionDeclaration -> Typed.TypedTerm Syntax.LocalFunctionDeclaration
localFunctionDeclarationStandard x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "standard"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.csharp.syntax.LocalFunctionHeader
localFunctionHeader :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.TypeParameterList) -> Typed.TypedTerm Syntax.FormalParameterList -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] -> Typed.TypedTerm Syntax.LocalFunctionHeader
localFunctionHeader identifier typeParameters parameters constraints =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm identifier)},
        Model.Field {
          Model.fieldName = (Model.Name "typeParameters"),
          Model.fieldTerm = (Typed.unTypedTerm typeParameters)},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm parameters)},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Typed.unTypedTerm constraints)}]}))

-- | DSL accessor for the constraints field of hydra.ext.csharp.syntax.LocalFunctionHeader
localFunctionHeaderConstraints :: Typed.TypedTerm Syntax.LocalFunctionHeader -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause]
localFunctionHeaderConstraints x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"),
        Model.projectionFieldName = (Model.Name "constraints")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.LocalFunctionHeader
localFunctionHeaderIdentifier :: Typed.TypedTerm Syntax.LocalFunctionHeader -> Typed.TypedTerm Syntax.Identifier
localFunctionHeaderIdentifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"),
        Model.projectionFieldName = (Model.Name "identifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.LocalFunctionHeader
localFunctionHeaderLocalFunctionHeader :: Typed.TypedName Syntax.LocalFunctionHeader
localFunctionHeaderLocalFunctionHeader = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader")

-- | DSL accessor for the parameters field of hydra.ext.csharp.syntax.LocalFunctionHeader
localFunctionHeaderParameters :: Typed.TypedTerm Syntax.LocalFunctionHeader -> Typed.TypedTerm Syntax.FormalParameterList
localFunctionHeaderParameters x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"),
        Model.projectionFieldName = (Model.Name "parameters")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the typeParameters field of hydra.ext.csharp.syntax.LocalFunctionHeader
localFunctionHeaderTypeParameters :: Typed.TypedTerm Syntax.LocalFunctionHeader -> Typed.TypedTerm (Maybe Syntax.TypeParameterList)
localFunctionHeaderTypeParameters x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"),
        Model.projectionFieldName = (Model.Name "typeParameters")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the constraints field of hydra.ext.csharp.syntax.LocalFunctionHeader
localFunctionHeaderWithConstraints :: Typed.TypedTerm Syntax.LocalFunctionHeader -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] -> Typed.TypedTerm Syntax.LocalFunctionHeader
localFunctionHeaderWithConstraints original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeParameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"),
              Model.projectionFieldName = (Model.Name "typeParameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.LocalFunctionHeader
localFunctionHeaderWithIdentifier :: Typed.TypedTerm Syntax.LocalFunctionHeader -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.LocalFunctionHeader
localFunctionHeaderWithIdentifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "typeParameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"),
              Model.projectionFieldName = (Model.Name "typeParameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the parameters field of hydra.ext.csharp.syntax.LocalFunctionHeader
localFunctionHeaderWithParameters :: Typed.TypedTerm Syntax.LocalFunctionHeader -> Typed.TypedTerm Syntax.FormalParameterList -> Typed.TypedTerm Syntax.LocalFunctionHeader
localFunctionHeaderWithParameters original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeParameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"),
              Model.projectionFieldName = (Model.Name "typeParameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the typeParameters field of hydra.ext.csharp.syntax.LocalFunctionHeader
localFunctionHeaderWithTypeParameters :: Typed.TypedTerm Syntax.LocalFunctionHeader -> Typed.TypedTerm (Maybe Syntax.TypeParameterList) -> Typed.TypedTerm Syntax.LocalFunctionHeader
localFunctionHeaderWithTypeParameters original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeParameters"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionHeader"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the async variant of hydra.ext.csharp.syntax.LocalFunctionModifier
localFunctionModifierAsync :: Typed.TypedTerm Syntax.LocalFunctionModifier
localFunctionModifierAsync =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "async"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.csharp.syntax.LocalFunctionModifier
localFunctionModifierLocalFunctionModifier :: Typed.TypedName Syntax.LocalFunctionModifier
localFunctionModifierLocalFunctionModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.LocalFunctionModifier")

-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.LocalFunctionModifier
localFunctionModifierRef :: Typed.TypedTerm Syntax.RefLocalFunctionModifier -> Typed.TypedTerm Syntax.LocalFunctionModifier
localFunctionModifierRef x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalFunctionModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "ref"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the explicitlyTyped variant of hydra.ext.csharp.syntax.LocalVariableDeclaration
localVariableDeclarationExplicitlyTyped :: Typed.TypedTerm Syntax.ExplicitlyTypedLocalVariableDeclaration -> Typed.TypedTerm Syntax.LocalVariableDeclaration
localVariableDeclarationExplicitlyTyped x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalVariableDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "explicitlyTyped"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the implicitlyTyped variant of hydra.ext.csharp.syntax.LocalVariableDeclaration
localVariableDeclarationImplicitlyTyped :: Typed.TypedTerm Syntax.ImplicitlyTypedLocalVariableDeclaration -> Typed.TypedTerm Syntax.LocalVariableDeclaration
localVariableDeclarationImplicitlyTyped x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalVariableDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "implicitlyTyped"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.LocalVariableDeclaration
localVariableDeclarationLocalVariableDeclaration :: Typed.TypedName Syntax.LocalVariableDeclaration
localVariableDeclarationLocalVariableDeclaration =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.LocalVariableDeclaration")

-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.LocalVariableDeclaration
localVariableDeclarationRef :: Typed.TypedTerm Syntax.RefLocalVariableDeclaration -> Typed.TypedTerm Syntax.LocalVariableDeclaration
localVariableDeclarationRef x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalVariableDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "ref"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.LocalVariableInitializer
localVariableInitializerExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.LocalVariableInitializer
localVariableInitializerExpression x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalVariableInitializer"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "expression"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the initializer variant of hydra.ext.csharp.syntax.LocalVariableInitializer
localVariableInitializerInitializer :: Typed.TypedTerm Syntax.ArrayInitializer -> Typed.TypedTerm Syntax.LocalVariableInitializer
localVariableInitializerInitializer x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalVariableInitializer"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "initializer"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.LocalVariableInitializer
localVariableInitializerLocalVariableInitializer :: Typed.TypedName Syntax.LocalVariableInitializer
localVariableInitializerLocalVariableInitializer =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.LocalVariableInitializer")

-- | DSL name token for hydra.ext.csharp.syntax.LocalVariableType
localVariableTypeLocalVariableType :: Typed.TypedName Syntax.LocalVariableType
localVariableTypeLocalVariableType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.LocalVariableType")

-- | DSL injection for the type variant of hydra.ext.csharp.syntax.LocalVariableType
localVariableTypeType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.LocalVariableType
localVariableTypeType x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalVariableType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "type"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the var variant of hydra.ext.csharp.syntax.LocalVariableType
localVariableTypeVar :: Typed.TypedTerm Syntax.LocalVariableType
localVariableTypeVar =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LocalVariableType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "var"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL constructor for hydra.ext.csharp.syntax.LockStatement
lockStatement :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.LockStatement
lockStatement expression body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LockStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm expression)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.LockStatement
lockStatementBody :: Typed.TypedTerm Syntax.LockStatement -> Typed.TypedTerm Syntax.EmbeddedStatement
lockStatementBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LockStatement"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.LockStatement
lockStatementExpression :: Typed.TypedTerm Syntax.LockStatement -> Typed.TypedTerm Syntax.Expression
lockStatementExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LockStatement"),
        Model.projectionFieldName = (Model.Name "expression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.LockStatement
lockStatementLockStatement :: Typed.TypedName Syntax.LockStatement
lockStatementLockStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.LockStatement")

-- | DSL updater for the body field of hydra.ext.csharp.syntax.LockStatement
lockStatementWithBody :: Typed.TypedTerm Syntax.LockStatement -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.LockStatement
lockStatementWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LockStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LockStatement"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the expression field of hydra.ext.csharp.syntax.LockStatement
lockStatementWithExpression :: Typed.TypedTerm Syntax.LockStatement -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.LockStatement
lockStatementWithExpression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.LockStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.LockStatement"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.MemberAccess
memberAccess :: Typed.TypedTerm Syntax.MemberAccessHead -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.MemberAccess
memberAccess head identifier typeArguments =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccess"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "head"),
          Model.fieldTerm = (Typed.unTypedTerm head)},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm identifier)},
        Model.Field {
          Model.fieldName = (Model.Name "typeArguments"),
          Model.fieldTerm = (Typed.unTypedTerm typeArguments)}]}))

-- | DSL accessor for the head field of hydra.ext.csharp.syntax.MemberAccess
memberAccessHead :: Typed.TypedTerm Syntax.MemberAccess -> Typed.TypedTerm Syntax.MemberAccessHead
memberAccessHead x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccess"),
        Model.projectionFieldName = (Model.Name "head")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.MemberAccessHead
memberAccessHeadMemberAccessHead :: Typed.TypedName Syntax.MemberAccessHead
memberAccessHeadMemberAccessHead = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.MemberAccessHead")

-- | DSL injection for the predefined variant of hydra.ext.csharp.syntax.MemberAccessHead
memberAccessHeadPredefined :: Typed.TypedTerm Syntax.PredefinedType -> Typed.TypedTerm Syntax.MemberAccessHead
memberAccessHeadPredefined x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccessHead"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "predefined"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the primary variant of hydra.ext.csharp.syntax.MemberAccessHead
memberAccessHeadPrimary :: Typed.TypedTerm Syntax.PrimaryExpression -> Typed.TypedTerm Syntax.MemberAccessHead
memberAccessHeadPrimary x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccessHead"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "primary"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the qualifiedAlias variant of hydra.ext.csharp.syntax.MemberAccessHead
memberAccessHeadQualifiedAlias :: Typed.TypedTerm Syntax.QualifiedAliasMember -> Typed.TypedTerm Syntax.MemberAccessHead
memberAccessHeadQualifiedAlias x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccessHead"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "qualifiedAlias"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.MemberAccess
memberAccessIdentifier :: Typed.TypedTerm Syntax.MemberAccess -> Typed.TypedTerm Syntax.Identifier
memberAccessIdentifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccess"),
        Model.projectionFieldName = (Model.Name "identifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.MemberAccess
memberAccessMemberAccess :: Typed.TypedName Syntax.MemberAccess
memberAccessMemberAccess = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.MemberAccess")

-- | DSL accessor for the typeArguments field of hydra.ext.csharp.syntax.MemberAccess
memberAccessTypeArguments :: Typed.TypedTerm Syntax.MemberAccess -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList)
memberAccessTypeArguments x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccess"),
        Model.projectionFieldName = (Model.Name "typeArguments")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the head field of hydra.ext.csharp.syntax.MemberAccess
memberAccessWithHead :: Typed.TypedTerm Syntax.MemberAccess -> Typed.TypedTerm Syntax.MemberAccessHead -> Typed.TypedTerm Syntax.MemberAccess
memberAccessWithHead original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccess"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "head"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccess"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeArguments"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccess"),
              Model.projectionFieldName = (Model.Name "typeArguments")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.MemberAccess
memberAccessWithIdentifier :: Typed.TypedTerm Syntax.MemberAccess -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.MemberAccess
memberAccessWithIdentifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccess"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "head"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccess"),
              Model.projectionFieldName = (Model.Name "head")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "typeArguments"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccess"),
              Model.projectionFieldName = (Model.Name "typeArguments")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the typeArguments field of hydra.ext.csharp.syntax.MemberAccess
memberAccessWithTypeArguments :: Typed.TypedTerm Syntax.MemberAccess -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.MemberAccess
memberAccessWithTypeArguments original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccess"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "head"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccess"),
              Model.projectionFieldName = (Model.Name "head")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberAccess"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeArguments"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the assignment variant of hydra.ext.csharp.syntax.MemberDeclarator
memberDeclaratorAssignment :: Typed.TypedTerm Syntax.AssignmentMemberDeclarator -> Typed.TypedTerm Syntax.MemberDeclarator
memberDeclaratorAssignment x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberDeclarator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "assignment"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the baseAccess variant of hydra.ext.csharp.syntax.MemberDeclarator
memberDeclaratorBaseAccess :: Typed.TypedTerm Syntax.BaseAccess -> Typed.TypedTerm Syntax.MemberDeclarator
memberDeclaratorBaseAccess x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberDeclarator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "baseAccess"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for the hydra.ext.csharp.syntax.MemberDeclaratorList wrapper
memberDeclaratorList :: Typed.TypedTerm [Syntax.MemberDeclarator] -> Typed.TypedTerm Syntax.MemberDeclaratorList
memberDeclaratorList x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberDeclaratorList"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.MemberDeclaratorList
memberDeclaratorListMemberDeclaratorList :: Typed.TypedName Syntax.MemberDeclaratorList
memberDeclaratorListMemberDeclaratorList = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.MemberDeclaratorList")

-- | DSL injection for the memberAccess variant of hydra.ext.csharp.syntax.MemberDeclarator
memberDeclaratorMemberAccess :: Typed.TypedTerm Syntax.MemberAccess -> Typed.TypedTerm Syntax.MemberDeclarator
memberDeclaratorMemberAccess x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberDeclarator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "memberAccess"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.MemberDeclarator
memberDeclaratorMemberDeclarator :: Typed.TypedName Syntax.MemberDeclarator
memberDeclaratorMemberDeclarator = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.MemberDeclarator")

-- | DSL injection for the name variant of hydra.ext.csharp.syntax.MemberDeclarator
memberDeclaratorName :: Typed.TypedTerm Syntax.SimpleName -> Typed.TypedTerm Syntax.MemberDeclarator
memberDeclaratorName x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberDeclarator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "name"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the nullConditionalProjectionInitializer variant of hydra.ext.csharp.syntax.MemberDeclarator
memberDeclaratorNullConditionalProjectionInitializer :: Typed.TypedTerm Syntax.NullConditionalProjectionInitializer -> Typed.TypedTerm Syntax.MemberDeclarator
memberDeclaratorNullConditionalProjectionInitializer x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberDeclarator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "nullConditionalProjectionInitializer"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.csharp.syntax.MemberInitializer
memberInitializer :: Typed.TypedTerm Syntax.InitializerTarget -> Typed.TypedTerm Syntax.InitializerValue -> Typed.TypedTerm Syntax.MemberInitializer
memberInitializer target value =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberInitializer"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "target"),
          Model.fieldTerm = (Typed.unTypedTerm target)},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Typed.unTypedTerm value)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.MemberInitializer
memberInitializerMemberInitializer :: Typed.TypedName Syntax.MemberInitializer
memberInitializerMemberInitializer = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.MemberInitializer")

-- | DSL accessor for the target field of hydra.ext.csharp.syntax.MemberInitializer
memberInitializerTarget :: Typed.TypedTerm Syntax.MemberInitializer -> Typed.TypedTerm Syntax.InitializerTarget
memberInitializerTarget x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberInitializer"),
        Model.projectionFieldName = (Model.Name "target")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the value field of hydra.ext.csharp.syntax.MemberInitializer
memberInitializerValue :: Typed.TypedTerm Syntax.MemberInitializer -> Typed.TypedTerm Syntax.InitializerValue
memberInitializerValue x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberInitializer"),
        Model.projectionFieldName = (Model.Name "value")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the target field of hydra.ext.csharp.syntax.MemberInitializer
memberInitializerWithTarget :: Typed.TypedTerm Syntax.MemberInitializer -> Typed.TypedTerm Syntax.InitializerTarget -> Typed.TypedTerm Syntax.MemberInitializer
memberInitializerWithTarget original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberInitializer"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "target"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberInitializer"),
              Model.projectionFieldName = (Model.Name "value")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the value field of hydra.ext.csharp.syntax.MemberInitializer
memberInitializerWithValue :: Typed.TypedTerm Syntax.MemberInitializer -> Typed.TypedTerm Syntax.InitializerValue -> Typed.TypedTerm Syntax.MemberInitializer
memberInitializerWithValue original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberInitializer"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "target"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberInitializer"),
              Model.projectionFieldName = (Model.Name "target")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.MemberName
memberName :: Typed.TypedTerm (Maybe Syntax.TypeName) -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.MemberName
memberName interfaceType identifier =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberName"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "interfaceType"),
          Model.fieldTerm = (Typed.unTypedTerm interfaceType)},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm identifier)}]}))

-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.MemberName
memberNameIdentifier :: Typed.TypedTerm Syntax.MemberName -> Typed.TypedTerm Syntax.Identifier
memberNameIdentifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberName"),
        Model.projectionFieldName = (Model.Name "identifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the interfaceType field of hydra.ext.csharp.syntax.MemberName
memberNameInterfaceType :: Typed.TypedTerm Syntax.MemberName -> Typed.TypedTerm (Maybe Syntax.TypeName)
memberNameInterfaceType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberName"),
        Model.projectionFieldName = (Model.Name "interfaceType")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.MemberName
memberNameMemberName :: Typed.TypedName Syntax.MemberName
memberNameMemberName = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.MemberName")

-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.MemberName
memberNameWithIdentifier :: Typed.TypedTerm Syntax.MemberName -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.MemberName
memberNameWithIdentifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberName"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "interfaceType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberName"),
              Model.projectionFieldName = (Model.Name "interfaceType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the interfaceType field of hydra.ext.csharp.syntax.MemberName
memberNameWithInterfaceType :: Typed.TypedTerm Syntax.MemberName -> Typed.TypedTerm (Maybe Syntax.TypeName) -> Typed.TypedTerm Syntax.MemberName
memberNameWithInterfaceType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberName"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "interfaceType"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MemberName"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the block variant of hydra.ext.csharp.syntax.MethodBody
methodBodyBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.MethodBody
methodBodyBlock x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "block"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the empty variant of hydra.ext.csharp.syntax.MethodBody
methodBodyEmpty :: Typed.TypedTerm Syntax.MethodBody
methodBodyEmpty =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "empty"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.MethodBody
methodBodyExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.MethodBody
methodBodyExpression x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "expression"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.MethodBody
methodBodyMethodBody :: Typed.TypedName Syntax.MethodBody
methodBodyMethodBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.MethodBody")

-- | DSL injection for the nullConditionalInvocation variant of hydra.ext.csharp.syntax.MethodBody
methodBodyNullConditionalInvocation :: Typed.TypedTerm Syntax.NullConditionalInvocationExpression -> Typed.TypedTerm Syntax.MethodBody
methodBodyNullConditionalInvocation x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "nullConditionalInvocation"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.MethodDeclaration
methodDeclarationMethodDeclaration :: Typed.TypedName Syntax.MethodDeclaration
methodDeclarationMethodDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.MethodDeclaration")

-- | DSL injection for the refReturn variant of hydra.ext.csharp.syntax.MethodDeclaration
methodDeclarationRefReturn :: Typed.TypedTerm Syntax.RefReturnMethodDeclaration -> Typed.TypedTerm Syntax.MethodDeclaration
methodDeclarationRefReturn x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "refReturn"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the standard variant of hydra.ext.csharp.syntax.MethodDeclaration
methodDeclarationStandard :: Typed.TypedTerm Syntax.StandardMethodDeclaration -> Typed.TypedTerm Syntax.MethodDeclaration
methodDeclarationStandard x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "standard"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.csharp.syntax.MethodHeader
methodHeader :: Typed.TypedTerm Syntax.MemberName -> Typed.TypedTerm (Maybe Syntax.TypeParameterList) -> Typed.TypedTerm (Maybe Syntax.FormalParameterList) -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] -> Typed.TypedTerm Syntax.MethodHeader
methodHeader name typeParameters parameters constraints =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "typeParameters"),
          Model.fieldTerm = (Typed.unTypedTerm typeParameters)},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm parameters)},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Typed.unTypedTerm constraints)}]}))

-- | DSL accessor for the constraints field of hydra.ext.csharp.syntax.MethodHeader
methodHeaderConstraints :: Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause]
methodHeaderConstraints x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"),
        Model.projectionFieldName = (Model.Name "constraints")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.MethodHeader
methodHeaderMethodHeader :: Typed.TypedName Syntax.MethodHeader
methodHeaderMethodHeader = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.MethodHeader")

-- | DSL accessor for the name field of hydra.ext.csharp.syntax.MethodHeader
methodHeaderName :: Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm Syntax.MemberName
methodHeaderName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the parameters field of hydra.ext.csharp.syntax.MethodHeader
methodHeaderParameters :: Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm (Maybe Syntax.FormalParameterList)
methodHeaderParameters x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"),
        Model.projectionFieldName = (Model.Name "parameters")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the typeParameters field of hydra.ext.csharp.syntax.MethodHeader
methodHeaderTypeParameters :: Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm (Maybe Syntax.TypeParameterList)
methodHeaderTypeParameters x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"),
        Model.projectionFieldName = (Model.Name "typeParameters")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the constraints field of hydra.ext.csharp.syntax.MethodHeader
methodHeaderWithConstraints :: Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] -> Typed.TypedTerm Syntax.MethodHeader
methodHeaderWithConstraints original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeParameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"),
              Model.projectionFieldName = (Model.Name "typeParameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the name field of hydra.ext.csharp.syntax.MethodHeader
methodHeaderWithName :: Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm Syntax.MemberName -> Typed.TypedTerm Syntax.MethodHeader
methodHeaderWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "typeParameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"),
              Model.projectionFieldName = (Model.Name "typeParameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the parameters field of hydra.ext.csharp.syntax.MethodHeader
methodHeaderWithParameters :: Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm (Maybe Syntax.FormalParameterList) -> Typed.TypedTerm Syntax.MethodHeader
methodHeaderWithParameters original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeParameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"),
              Model.projectionFieldName = (Model.Name "typeParameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the typeParameters field of hydra.ext.csharp.syntax.MethodHeader
methodHeaderWithTypeParameters :: Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm (Maybe Syntax.TypeParameterList) -> Typed.TypedTerm Syntax.MethodHeader
methodHeaderWithTypeParameters original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeParameters"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodHeader"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the async variant of hydra.ext.csharp.syntax.MethodModifier
methodModifierAsync :: Typed.TypedTerm Syntax.MethodModifier
methodModifierAsync =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "async"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.csharp.syntax.MethodModifier
methodModifierMethodModifier :: Typed.TypedName Syntax.MethodModifier
methodModifierMethodModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.MethodModifier")

-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.MethodModifier
methodModifierRef :: Typed.TypedTerm Syntax.RefMethodModifier -> Typed.TypedTerm Syntax.MethodModifier
methodModifierRef x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "ref"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.csharp.syntax.MethodModifiers
methodModifiers :: Typed.TypedTerm [Syntax.MethodModifier] -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.MethodModifiers
methodModifiers modifiers partial =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodModifiers"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm modifiers)},
        Model.Field {
          Model.fieldName = (Model.Name "partial"),
          Model.fieldTerm = (Typed.unTypedTerm partial)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.MethodModifiers
methodModifiersMethodModifiers :: Typed.TypedName Syntax.MethodModifiers
methodModifiersMethodModifiers = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.MethodModifiers")

-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.MethodModifiers
methodModifiersModifiers :: Typed.TypedTerm Syntax.MethodModifiers -> Typed.TypedTerm [Syntax.MethodModifier]
methodModifiersModifiers x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodModifiers"),
        Model.projectionFieldName = (Model.Name "modifiers")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the partial field of hydra.ext.csharp.syntax.MethodModifiers
methodModifiersPartial :: Typed.TypedTerm Syntax.MethodModifiers -> Typed.TypedTerm Bool
methodModifiersPartial x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodModifiers"),
        Model.projectionFieldName = (Model.Name "partial")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.MethodModifiers
methodModifiersWithModifiers :: Typed.TypedTerm Syntax.MethodModifiers -> Typed.TypedTerm [Syntax.MethodModifier] -> Typed.TypedTerm Syntax.MethodModifiers
methodModifiersWithModifiers original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodModifiers"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "partial"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodModifiers"),
              Model.projectionFieldName = (Model.Name "partial")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the partial field of hydra.ext.csharp.syntax.MethodModifiers
methodModifiersWithPartial :: Typed.TypedTerm Syntax.MethodModifiers -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.MethodModifiers
methodModifiersWithPartial original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodModifiers"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MethodModifiers"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "partial"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the binary variant of hydra.ext.csharp.syntax.MultiplicativeExpression
multiplicativeExpressionBinary :: Typed.TypedTerm Syntax.BinaryMultiplicativeExpression -> Typed.TypedTerm Syntax.MultiplicativeExpression
multiplicativeExpressionBinary x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MultiplicativeExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "binary"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.MultiplicativeExpression
multiplicativeExpressionMultiplicativeExpression :: Typed.TypedName Syntax.MultiplicativeExpression
multiplicativeExpressionMultiplicativeExpression =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.MultiplicativeExpression")

-- | DSL injection for the simple variant of hydra.ext.csharp.syntax.MultiplicativeExpression
multiplicativeExpressionSimple :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.MultiplicativeExpression
multiplicativeExpressionSimple x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MultiplicativeExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "simple"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the divide variant of hydra.ext.csharp.syntax.MultiplicativeOperator
multiplicativeOperatorDivide :: Typed.TypedTerm Syntax.MultiplicativeOperator
multiplicativeOperatorDivide =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MultiplicativeOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "divide"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the modulo variant of hydra.ext.csharp.syntax.MultiplicativeOperator
multiplicativeOperatorModulo :: Typed.TypedTerm Syntax.MultiplicativeOperator
multiplicativeOperatorModulo =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MultiplicativeOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "modulo"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.csharp.syntax.MultiplicativeOperator
multiplicativeOperatorMultiplicativeOperator :: Typed.TypedName Syntax.MultiplicativeOperator
multiplicativeOperatorMultiplicativeOperator =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.MultiplicativeOperator")

-- | DSL injection for the times variant of hydra.ext.csharp.syntax.MultiplicativeOperator
multiplicativeOperatorTimes :: Typed.TypedTerm Syntax.MultiplicativeOperator
multiplicativeOperatorTimes =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.MultiplicativeOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "times"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL constructor for hydra.ext.csharp.syntax.NamedArgument
namedArgument :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.AttributeArgumentExpression -> Typed.TypedTerm Syntax.NamedArgument
namedArgument name value =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedArgument"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Typed.unTypedTerm value)}]}))

-- | DSL constructor for the hydra.ext.csharp.syntax.NamedArgumentList wrapper
namedArgumentList :: Typed.TypedTerm [Syntax.NamedArgument] -> Typed.TypedTerm Syntax.NamedArgumentList
namedArgumentList x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedArgumentList"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.NamedArgumentList
namedArgumentListNamedArgumentList :: Typed.TypedName Syntax.NamedArgumentList
namedArgumentListNamedArgumentList = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NamedArgumentList")

-- | DSL accessor for the name field of hydra.ext.csharp.syntax.NamedArgument
namedArgumentName :: Typed.TypedTerm Syntax.NamedArgument -> Typed.TypedTerm Syntax.Identifier
namedArgumentName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedArgument"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.NamedArgument
namedArgumentNamedArgument :: Typed.TypedName Syntax.NamedArgument
namedArgumentNamedArgument = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NamedArgument")

-- | DSL accessor for the value field of hydra.ext.csharp.syntax.NamedArgument
namedArgumentValue :: Typed.TypedTerm Syntax.NamedArgument -> Typed.TypedTerm Syntax.AttributeArgumentExpression
namedArgumentValue x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedArgument"),
        Model.projectionFieldName = (Model.Name "value")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the name field of hydra.ext.csharp.syntax.NamedArgument
namedArgumentWithName :: Typed.TypedTerm Syntax.NamedArgument -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.NamedArgument
namedArgumentWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedArgument"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedArgument"),
              Model.projectionFieldName = (Model.Name "value")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the value field of hydra.ext.csharp.syntax.NamedArgument
namedArgumentWithValue :: Typed.TypedTerm Syntax.NamedArgument -> Typed.TypedTerm Syntax.AttributeArgumentExpression -> Typed.TypedTerm Syntax.NamedArgument
namedArgumentWithValue original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedArgument"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedArgument"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.NamedEntity
namedEntity :: Typed.TypedTerm Syntax.NamedEntityTarget -> Typed.TypedTerm [Syntax.NamedEntityPart] -> Typed.TypedTerm Syntax.NamedEntity
namedEntity target parts =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntity"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "target"),
          Model.fieldTerm = (Typed.unTypedTerm target)},
        Model.Field {
          Model.fieldName = (Model.Name "parts"),
          Model.fieldTerm = (Typed.unTypedTerm parts)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.NamedEntity
namedEntityNamedEntity :: Typed.TypedName Syntax.NamedEntity
namedEntityNamedEntity = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NamedEntity")

-- | DSL constructor for hydra.ext.csharp.syntax.NamedEntityPart
namedEntityPart :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.NamedEntityPart
namedEntityPart identifier typeArguments =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntityPart"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm identifier)},
        Model.Field {
          Model.fieldName = (Model.Name "typeArguments"),
          Model.fieldTerm = (Typed.unTypedTerm typeArguments)}]}))

-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.NamedEntityPart
namedEntityPartIdentifier :: Typed.TypedTerm Syntax.NamedEntityPart -> Typed.TypedTerm Syntax.Identifier
namedEntityPartIdentifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntityPart"),
        Model.projectionFieldName = (Model.Name "identifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.NamedEntityPart
namedEntityPartNamedEntityPart :: Typed.TypedName Syntax.NamedEntityPart
namedEntityPartNamedEntityPart = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NamedEntityPart")

-- | DSL accessor for the typeArguments field of hydra.ext.csharp.syntax.NamedEntityPart
namedEntityPartTypeArguments :: Typed.TypedTerm Syntax.NamedEntityPart -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList)
namedEntityPartTypeArguments x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntityPart"),
        Model.projectionFieldName = (Model.Name "typeArguments")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.NamedEntityPart
namedEntityPartWithIdentifier :: Typed.TypedTerm Syntax.NamedEntityPart -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.NamedEntityPart
namedEntityPartWithIdentifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntityPart"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "typeArguments"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntityPart"),
              Model.projectionFieldName = (Model.Name "typeArguments")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the typeArguments field of hydra.ext.csharp.syntax.NamedEntityPart
namedEntityPartWithTypeArguments :: Typed.TypedTerm Syntax.NamedEntityPart -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.NamedEntityPart
namedEntityPartWithTypeArguments original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntityPart"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntityPart"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeArguments"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL accessor for the parts field of hydra.ext.csharp.syntax.NamedEntity
namedEntityParts :: Typed.TypedTerm Syntax.NamedEntity -> Typed.TypedTerm [Syntax.NamedEntityPart]
namedEntityParts x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntity"),
        Model.projectionFieldName = (Model.Name "parts")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the target field of hydra.ext.csharp.syntax.NamedEntity
namedEntityTarget :: Typed.TypedTerm Syntax.NamedEntity -> Typed.TypedTerm Syntax.NamedEntityTarget
namedEntityTarget x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntity"),
        Model.projectionFieldName = (Model.Name "target")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL injection for the base variant of hydra.ext.csharp.syntax.NamedEntityTarget
namedEntityTargetBase :: Typed.TypedTerm Syntax.NamedEntityTarget
namedEntityTargetBase =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntityTarget"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "base"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the name variant of hydra.ext.csharp.syntax.NamedEntityTarget
namedEntityTargetName :: Typed.TypedTerm Syntax.SimpleName -> Typed.TypedTerm Syntax.NamedEntityTarget
namedEntityTargetName x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntityTarget"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "name"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.NamedEntityTarget
namedEntityTargetNamedEntityTarget :: Typed.TypedName Syntax.NamedEntityTarget
namedEntityTargetNamedEntityTarget = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NamedEntityTarget")

-- | DSL injection for the predefinedType variant of hydra.ext.csharp.syntax.NamedEntityTarget
namedEntityTargetPredefinedType :: Typed.TypedTerm Syntax.PredefinedType -> Typed.TypedTerm Syntax.NamedEntityTarget
namedEntityTargetPredefinedType x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntityTarget"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "predefinedType"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the qualifiedAliasMember variant of hydra.ext.csharp.syntax.NamedEntityTarget
namedEntityTargetQualifiedAliasMember :: Typed.TypedTerm Syntax.QualifiedAliasMember -> Typed.TypedTerm Syntax.NamedEntityTarget
namedEntityTargetQualifiedAliasMember x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntityTarget"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "qualifiedAliasMember"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the this variant of hydra.ext.csharp.syntax.NamedEntityTarget
namedEntityTargetThis :: Typed.TypedTerm Syntax.NamedEntityTarget
namedEntityTargetThis =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntityTarget"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "this"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL updater for the parts field of hydra.ext.csharp.syntax.NamedEntity
namedEntityWithParts :: Typed.TypedTerm Syntax.NamedEntity -> Typed.TypedTerm [Syntax.NamedEntityPart] -> Typed.TypedTerm Syntax.NamedEntity
namedEntityWithParts original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntity"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "target"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntity"),
              Model.projectionFieldName = (Model.Name "target")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parts"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the target field of hydra.ext.csharp.syntax.NamedEntity
namedEntityWithTarget :: Typed.TypedTerm Syntax.NamedEntity -> Typed.TypedTerm Syntax.NamedEntityTarget -> Typed.TypedTerm Syntax.NamedEntity
namedEntityWithTarget original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntity"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "target"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "parts"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamedEntity"),
              Model.projectionFieldName = (Model.Name "parts")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.NamespaceBody
namespaceBody :: Typed.TypedTerm [Syntax.ExternAliasDirective] -> Typed.TypedTerm [Syntax.UsingDirective] -> Typed.TypedTerm [Syntax.NamespaceMemberDeclaration] -> Typed.TypedTerm Syntax.NamespaceBody
namespaceBody externs usings members =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceBody"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "externs"),
          Model.fieldTerm = (Typed.unTypedTerm externs)},
        Model.Field {
          Model.fieldName = (Model.Name "usings"),
          Model.fieldTerm = (Typed.unTypedTerm usings)},
        Model.Field {
          Model.fieldName = (Model.Name "members"),
          Model.fieldTerm = (Typed.unTypedTerm members)}]}))

-- | DSL accessor for the externs field of hydra.ext.csharp.syntax.NamespaceBody
namespaceBodyExterns :: Typed.TypedTerm Syntax.NamespaceBody -> Typed.TypedTerm [Syntax.ExternAliasDirective]
namespaceBodyExterns x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceBody"),
        Model.projectionFieldName = (Model.Name "externs")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the members field of hydra.ext.csharp.syntax.NamespaceBody
namespaceBodyMembers :: Typed.TypedTerm Syntax.NamespaceBody -> Typed.TypedTerm [Syntax.NamespaceMemberDeclaration]
namespaceBodyMembers x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceBody"),
        Model.projectionFieldName = (Model.Name "members")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.NamespaceBody
namespaceBodyNamespaceBody :: Typed.TypedName Syntax.NamespaceBody
namespaceBodyNamespaceBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NamespaceBody")

-- | DSL accessor for the usings field of hydra.ext.csharp.syntax.NamespaceBody
namespaceBodyUsings :: Typed.TypedTerm Syntax.NamespaceBody -> Typed.TypedTerm [Syntax.UsingDirective]
namespaceBodyUsings x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceBody"),
        Model.projectionFieldName = (Model.Name "usings")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the externs field of hydra.ext.csharp.syntax.NamespaceBody
namespaceBodyWithExterns :: Typed.TypedTerm Syntax.NamespaceBody -> Typed.TypedTerm [Syntax.ExternAliasDirective] -> Typed.TypedTerm Syntax.NamespaceBody
namespaceBodyWithExterns original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceBody"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "externs"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "usings"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceBody"),
              Model.projectionFieldName = (Model.Name "usings")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "members"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceBody"),
              Model.projectionFieldName = (Model.Name "members")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the members field of hydra.ext.csharp.syntax.NamespaceBody
namespaceBodyWithMembers :: Typed.TypedTerm Syntax.NamespaceBody -> Typed.TypedTerm [Syntax.NamespaceMemberDeclaration] -> Typed.TypedTerm Syntax.NamespaceBody
namespaceBodyWithMembers original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceBody"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "externs"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceBody"),
              Model.projectionFieldName = (Model.Name "externs")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usings"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceBody"),
              Model.projectionFieldName = (Model.Name "usings")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "members"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the usings field of hydra.ext.csharp.syntax.NamespaceBody
namespaceBodyWithUsings :: Typed.TypedTerm Syntax.NamespaceBody -> Typed.TypedTerm [Syntax.UsingDirective] -> Typed.TypedTerm Syntax.NamespaceBody
namespaceBodyWithUsings original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceBody"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "externs"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceBody"),
              Model.projectionFieldName = (Model.Name "externs")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usings"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "members"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceBody"),
              Model.projectionFieldName = (Model.Name "members")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.NamespaceDeclaration
namespaceDeclaration :: Typed.TypedTerm Syntax.QualifiedIdentifier -> Typed.TypedTerm Syntax.NamespaceBody -> Typed.TypedTerm Syntax.NamespaceDeclaration
namespaceDeclaration name body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.NamespaceDeclaration
namespaceDeclarationBody :: Typed.TypedTerm Syntax.NamespaceDeclaration -> Typed.TypedTerm Syntax.NamespaceBody
namespaceDeclarationBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceDeclaration"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the name field of hydra.ext.csharp.syntax.NamespaceDeclaration
namespaceDeclarationName :: Typed.TypedTerm Syntax.NamespaceDeclaration -> Typed.TypedTerm Syntax.QualifiedIdentifier
namespaceDeclarationName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceDeclaration"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.NamespaceDeclaration
namespaceDeclarationNamespaceDeclaration :: Typed.TypedName Syntax.NamespaceDeclaration
namespaceDeclarationNamespaceDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NamespaceDeclaration")

-- | DSL updater for the body field of hydra.ext.csharp.syntax.NamespaceDeclaration
namespaceDeclarationWithBody :: Typed.TypedTerm Syntax.NamespaceDeclaration -> Typed.TypedTerm Syntax.NamespaceBody -> Typed.TypedTerm Syntax.NamespaceDeclaration
namespaceDeclarationWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the name field of hydra.ext.csharp.syntax.NamespaceDeclaration
namespaceDeclarationWithName :: Typed.TypedTerm Syntax.NamespaceDeclaration -> Typed.TypedTerm Syntax.QualifiedIdentifier -> Typed.TypedTerm Syntax.NamespaceDeclaration
namespaceDeclarationWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the namespace variant of hydra.ext.csharp.syntax.NamespaceMemberDeclaration
namespaceMemberDeclarationNamespace :: Typed.TypedTerm Syntax.NamespaceDeclaration -> Typed.TypedTerm Syntax.NamespaceMemberDeclaration
namespaceMemberDeclarationNamespace x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceMemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "namespace"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.NamespaceMemberDeclaration
namespaceMemberDeclarationNamespaceMemberDeclaration :: Typed.TypedName Syntax.NamespaceMemberDeclaration
namespaceMemberDeclarationNamespaceMemberDeclaration =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NamespaceMemberDeclaration")

-- | DSL injection for the type variant of hydra.ext.csharp.syntax.NamespaceMemberDeclaration
namespaceMemberDeclarationType :: Typed.TypedTerm Syntax.TypeDeclaration -> Typed.TypedTerm Syntax.NamespaceMemberDeclaration
namespaceMemberDeclarationType x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceMemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "type"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for the hydra.ext.csharp.syntax.NamespaceName wrapper
namespaceName :: Typed.TypedTerm Syntax.NamespaceOrTypeName -> Typed.TypedTerm Syntax.NamespaceName
namespaceName x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceName"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.NamespaceName
namespaceNameNamespaceName :: Typed.TypedName Syntax.NamespaceName
namespaceNameNamespaceName = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NamespaceName")

-- | DSL injection for the alias variant of hydra.ext.csharp.syntax.NamespaceOrTypeName
namespaceOrTypeNameAlias :: Typed.TypedTerm Syntax.QualifiedAliasMember -> Typed.TypedTerm Syntax.NamespaceOrTypeName
namespaceOrTypeNameAlias x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceOrTypeName"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "alias"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the identifier variant of hydra.ext.csharp.syntax.NamespaceOrTypeName
namespaceOrTypeNameIdentifier :: Typed.TypedTerm Syntax.IdentifierNamespaceOrTypeName -> Typed.TypedTerm Syntax.NamespaceOrTypeName
namespaceOrTypeNameIdentifier x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceOrTypeName"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "identifier"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.NamespaceOrTypeName
namespaceOrTypeNameNamespaceOrTypeName :: Typed.TypedName Syntax.NamespaceOrTypeName
namespaceOrTypeNameNamespaceOrTypeName = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NamespaceOrTypeName")

-- | DSL injection for the qualified variant of hydra.ext.csharp.syntax.NamespaceOrTypeName
namespaceOrTypeNameQualified :: Typed.TypedTerm Syntax.QualifiedNamespaceOrTypeName -> Typed.TypedTerm Syntax.NamespaceOrTypeName
namespaceOrTypeNameQualified x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NamespaceOrTypeName"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "qualified"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression
nonArrayTypeArrayCreationExpression :: Typed.TypedTerm Syntax.NonArrayType -> Typed.TypedTerm Syntax.ExpressionList -> Typed.TypedTerm [Syntax.RankSpecifier] -> Typed.TypedTerm (Maybe Syntax.ArrayInitializer) -> Typed.TypedTerm Syntax.NonArrayTypeArrayCreationExpression
nonArrayTypeArrayCreationExpression type_ expressions rankSpecifiers initializer =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "expressions"),
          Model.fieldTerm = (Typed.unTypedTerm expressions)},
        Model.Field {
          Model.fieldName = (Model.Name "rankSpecifiers"),
          Model.fieldTerm = (Typed.unTypedTerm rankSpecifiers)},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Typed.unTypedTerm initializer)}]}))

-- | DSL accessor for the expressions field of hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression
nonArrayTypeArrayCreationExpressionExpressions :: Typed.TypedTerm Syntax.NonArrayTypeArrayCreationExpression -> Typed.TypedTerm Syntax.ExpressionList
nonArrayTypeArrayCreationExpressionExpressions x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"),
        Model.projectionFieldName = (Model.Name "expressions")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the initializer field of hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression
nonArrayTypeArrayCreationExpressionInitializer :: Typed.TypedTerm Syntax.NonArrayTypeArrayCreationExpression -> Typed.TypedTerm (Maybe Syntax.ArrayInitializer)
nonArrayTypeArrayCreationExpressionInitializer x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"),
        Model.projectionFieldName = (Model.Name "initializer")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression
nonArrayTypeArrayCreationExpressionNonArrayTypeArrayCreationExpression :: Typed.TypedName Syntax.NonArrayTypeArrayCreationExpression
nonArrayTypeArrayCreationExpressionNonArrayTypeArrayCreationExpression =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression")

-- | DSL accessor for the rankSpecifiers field of hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression
nonArrayTypeArrayCreationExpressionRankSpecifiers :: Typed.TypedTerm Syntax.NonArrayTypeArrayCreationExpression -> Typed.TypedTerm [Syntax.RankSpecifier]
nonArrayTypeArrayCreationExpressionRankSpecifiers x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"),
        Model.projectionFieldName = (Model.Name "rankSpecifiers")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression
nonArrayTypeArrayCreationExpressionType :: Typed.TypedTerm Syntax.NonArrayTypeArrayCreationExpression -> Typed.TypedTerm Syntax.NonArrayType
nonArrayTypeArrayCreationExpressionType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the expressions field of hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression
nonArrayTypeArrayCreationExpressionWithExpressions :: Typed.TypedTerm Syntax.NonArrayTypeArrayCreationExpression -> Typed.TypedTerm Syntax.ExpressionList -> Typed.TypedTerm Syntax.NonArrayTypeArrayCreationExpression
nonArrayTypeArrayCreationExpressionWithExpressions original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expressions"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "rankSpecifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"),
              Model.projectionFieldName = (Model.Name "rankSpecifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"),
              Model.projectionFieldName = (Model.Name "initializer")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the initializer field of hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression
nonArrayTypeArrayCreationExpressionWithInitializer :: Typed.TypedTerm Syntax.NonArrayTypeArrayCreationExpression -> Typed.TypedTerm (Maybe Syntax.ArrayInitializer) -> Typed.TypedTerm Syntax.NonArrayTypeArrayCreationExpression
nonArrayTypeArrayCreationExpressionWithInitializer original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expressions"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"),
              Model.projectionFieldName = (Model.Name "expressions")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "rankSpecifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"),
              Model.projectionFieldName = (Model.Name "rankSpecifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the rankSpecifiers field of hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression
nonArrayTypeArrayCreationExpressionWithRankSpecifiers :: Typed.TypedTerm Syntax.NonArrayTypeArrayCreationExpression -> Typed.TypedTerm [Syntax.RankSpecifier] -> Typed.TypedTerm Syntax.NonArrayTypeArrayCreationExpression
nonArrayTypeArrayCreationExpressionWithRankSpecifiers original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expressions"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"),
              Model.projectionFieldName = (Model.Name "expressions")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "rankSpecifiers"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"),
              Model.projectionFieldName = (Model.Name "initializer")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression
nonArrayTypeArrayCreationExpressionWithType :: Typed.TypedTerm Syntax.NonArrayTypeArrayCreationExpression -> Typed.TypedTerm Syntax.NonArrayType -> Typed.TypedTerm Syntax.NonArrayTypeArrayCreationExpression
nonArrayTypeArrayCreationExpressionWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "expressions"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"),
              Model.projectionFieldName = (Model.Name "expressions")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "rankSpecifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"),
              Model.projectionFieldName = (Model.Name "rankSpecifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayTypeArrayCreationExpression"),
              Model.projectionFieldName = (Model.Name "initializer")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the class variant of hydra.ext.csharp.syntax.NonArrayType
nonArrayTypeClass :: Typed.TypedTerm Syntax.ClassType -> Typed.TypedTerm Syntax.NonArrayType
nonArrayTypeClass x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "class"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the delegate variant of hydra.ext.csharp.syntax.NonArrayType
nonArrayTypeDelegate :: Typed.TypedTerm Syntax.DelegateType -> Typed.TypedTerm Syntax.NonArrayType
nonArrayTypeDelegate x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "delegate"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the dynamic variant of hydra.ext.csharp.syntax.NonArrayType
nonArrayTypeDynamic :: Typed.TypedTerm Syntax.NonArrayType
nonArrayTypeDynamic =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "dynamic"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the interface variant of hydra.ext.csharp.syntax.NonArrayType
nonArrayTypeInterface :: Typed.TypedTerm Syntax.InterfaceType -> Typed.TypedTerm Syntax.NonArrayType
nonArrayTypeInterface x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "interface"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.NonArrayType
nonArrayTypeNonArrayType :: Typed.TypedName Syntax.NonArrayType
nonArrayTypeNonArrayType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NonArrayType")

-- | DSL injection for the parameter variant of hydra.ext.csharp.syntax.NonArrayType
nonArrayTypeParameter :: Typed.TypedTerm Syntax.TypeParameter -> Typed.TypedTerm Syntax.NonArrayType
nonArrayTypeParameter x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "parameter"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the pointer variant of hydra.ext.csharp.syntax.NonArrayType
nonArrayTypePointer :: Typed.TypedTerm Syntax.PointerType -> Typed.TypedTerm Syntax.NonArrayType
nonArrayTypePointer x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "pointer"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the value variant of hydra.ext.csharp.syntax.NonArrayType
nonArrayTypeValue :: Typed.TypedTerm Syntax.ValueType -> Typed.TypedTerm Syntax.NonArrayType
nonArrayTypeValue x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonArrayType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "value"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the conditional variant of hydra.ext.csharp.syntax.NonAssignmentExpression
nonAssignmentExpressionConditional :: Typed.TypedTerm Syntax.ConditionalExpression -> Typed.TypedTerm Syntax.NonAssignmentExpression
nonAssignmentExpressionConditional x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonAssignmentExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "conditional"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the declaration variant of hydra.ext.csharp.syntax.NonAssignmentExpression
nonAssignmentExpressionDeclaration :: Typed.TypedTerm Syntax.DeclarationExpression -> Typed.TypedTerm Syntax.NonAssignmentExpression
nonAssignmentExpressionDeclaration x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonAssignmentExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "declaration"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the lambda variant of hydra.ext.csharp.syntax.NonAssignmentExpression
nonAssignmentExpressionLambda :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm Syntax.NonAssignmentExpression
nonAssignmentExpressionLambda x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonAssignmentExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "lambda"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.NonAssignmentExpression
nonAssignmentExpressionNonAssignmentExpression :: Typed.TypedName Syntax.NonAssignmentExpression
nonAssignmentExpressionNonAssignmentExpression =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NonAssignmentExpression")

-- | DSL injection for the query variant of hydra.ext.csharp.syntax.NonAssignmentExpression
nonAssignmentExpressionQuery :: Typed.TypedTerm Syntax.QueryExpression -> Typed.TypedTerm Syntax.NonAssignmentExpression
nonAssignmentExpressionQuery x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NonAssignmentExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "query"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the binary variant of hydra.ext.csharp.syntax.NullCoalescingExpression
nullCoalescingExpressionBinary :: Typed.TypedTerm Syntax.BinaryNullCoalescingExpression -> Typed.TypedTerm Syntax.NullCoalescingExpression
nullCoalescingExpressionBinary x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullCoalescingExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "binary"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.NullCoalescingExpression
nullCoalescingExpressionNullCoalescingExpression :: Typed.TypedName Syntax.NullCoalescingExpression
nullCoalescingExpressionNullCoalescingExpression =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NullCoalescingExpression")

-- | DSL injection for the simple variant of hydra.ext.csharp.syntax.NullCoalescingExpression
nullCoalescingExpressionSimple :: Typed.TypedTerm Syntax.ConditionalOrExpression -> Typed.TypedTerm Syntax.NullCoalescingExpression
nullCoalescingExpressionSimple x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullCoalescingExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "simple"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the throw variant of hydra.ext.csharp.syntax.NullCoalescingExpression
nullCoalescingExpressionThrow :: Typed.TypedTerm Syntax.NullCoalescingExpression -> Typed.TypedTerm Syntax.NullCoalescingExpression
nullCoalescingExpressionThrow x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullCoalescingExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "throw"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.csharp.syntax.NullConditionalElementAccess
nullConditionalElementAccess :: Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression -> Typed.TypedTerm Syntax.ArgumentList -> Typed.TypedTerm [Syntax.DependentAccess] -> Typed.TypedTerm Syntax.NullConditionalElementAccess
nullConditionalElementAccess expression arguments dependentAccess =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalElementAccess"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm expression)},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Typed.unTypedTerm arguments)},
        Model.Field {
          Model.fieldName = (Model.Name "dependentAccess"),
          Model.fieldTerm = (Typed.unTypedTerm dependentAccess)}]}))

-- | DSL accessor for the arguments field of hydra.ext.csharp.syntax.NullConditionalElementAccess
nullConditionalElementAccessArguments :: Typed.TypedTerm Syntax.NullConditionalElementAccess -> Typed.TypedTerm Syntax.ArgumentList
nullConditionalElementAccessArguments x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalElementAccess"),
        Model.projectionFieldName = (Model.Name "arguments")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the dependentAccess field of hydra.ext.csharp.syntax.NullConditionalElementAccess
nullConditionalElementAccessDependentAccess :: Typed.TypedTerm Syntax.NullConditionalElementAccess -> Typed.TypedTerm [Syntax.DependentAccess]
nullConditionalElementAccessDependentAccess x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalElementAccess"),
        Model.projectionFieldName = (Model.Name "dependentAccess")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.NullConditionalElementAccess
nullConditionalElementAccessExpression :: Typed.TypedTerm Syntax.NullConditionalElementAccess -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression
nullConditionalElementAccessExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalElementAccess"),
        Model.projectionFieldName = (Model.Name "expression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.NullConditionalElementAccess
nullConditionalElementAccessNullConditionalElementAccess :: Typed.TypedName Syntax.NullConditionalElementAccess
nullConditionalElementAccessNullConditionalElementAccess =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NullConditionalElementAccess")

-- | DSL updater for the arguments field of hydra.ext.csharp.syntax.NullConditionalElementAccess
nullConditionalElementAccessWithArguments :: Typed.TypedTerm Syntax.NullConditionalElementAccess -> Typed.TypedTerm Syntax.ArgumentList -> Typed.TypedTerm Syntax.NullConditionalElementAccess
nullConditionalElementAccessWithArguments original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalElementAccess"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalElementAccess"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "dependentAccess"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalElementAccess"),
              Model.projectionFieldName = (Model.Name "dependentAccess")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the dependentAccess field of hydra.ext.csharp.syntax.NullConditionalElementAccess
nullConditionalElementAccessWithDependentAccess :: Typed.TypedTerm Syntax.NullConditionalElementAccess -> Typed.TypedTerm [Syntax.DependentAccess] -> Typed.TypedTerm Syntax.NullConditionalElementAccess
nullConditionalElementAccessWithDependentAccess original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalElementAccess"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalElementAccess"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalElementAccess"),
              Model.projectionFieldName = (Model.Name "arguments")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dependentAccess"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the expression field of hydra.ext.csharp.syntax.NullConditionalElementAccess
nullConditionalElementAccessWithExpression :: Typed.TypedTerm Syntax.NullConditionalElementAccess -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression -> Typed.TypedTerm Syntax.NullConditionalElementAccess
nullConditionalElementAccessWithExpression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalElementAccess"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalElementAccess"),
              Model.projectionFieldName = (Model.Name "arguments")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dependentAccess"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalElementAccess"),
              Model.projectionFieldName = (Model.Name "dependentAccess")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.NullConditionalInvocationExpression
nullConditionalInvocationExpression :: Typed.TypedTerm Syntax.NullConditionalInvocationExpressionHead -> Typed.TypedTerm (Maybe Syntax.ArgumentList) -> Typed.TypedTerm Syntax.NullConditionalInvocationExpression
nullConditionalInvocationExpression head arguments =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalInvocationExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "head"),
          Model.fieldTerm = (Typed.unTypedTerm head)},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Typed.unTypedTerm arguments)}]}))

-- | DSL accessor for the arguments field of hydra.ext.csharp.syntax.NullConditionalInvocationExpression
nullConditionalInvocationExpressionArguments :: Typed.TypedTerm Syntax.NullConditionalInvocationExpression -> Typed.TypedTerm (Maybe Syntax.ArgumentList)
nullConditionalInvocationExpressionArguments x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalInvocationExpression"),
        Model.projectionFieldName = (Model.Name "arguments")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the head field of hydra.ext.csharp.syntax.NullConditionalInvocationExpression
nullConditionalInvocationExpressionHead :: Typed.TypedTerm Syntax.NullConditionalInvocationExpression -> Typed.TypedTerm Syntax.NullConditionalInvocationExpressionHead
nullConditionalInvocationExpressionHead x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalInvocationExpression"),
        Model.projectionFieldName = (Model.Name "head")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL injection for the element variant of hydra.ext.csharp.syntax.NullConditionalInvocationExpressionHead
nullConditionalInvocationExpressionHeadElement :: Typed.TypedTerm Syntax.NullConditionalElementAccess -> Typed.TypedTerm Syntax.NullConditionalInvocationExpressionHead
nullConditionalInvocationExpressionHeadElement x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalInvocationExpressionHead"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "element"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the member variant of hydra.ext.csharp.syntax.NullConditionalInvocationExpressionHead
nullConditionalInvocationExpressionHeadMember :: Typed.TypedTerm Syntax.NullConditionalMemberAccess -> Typed.TypedTerm Syntax.NullConditionalInvocationExpressionHead
nullConditionalInvocationExpressionHeadMember x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalInvocationExpressionHead"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "member"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.NullConditionalInvocationExpressionHead
nullConditionalInvocationExpressionHeadNullConditionalInvocationExpressionHead :: Typed.TypedName Syntax.NullConditionalInvocationExpressionHead
nullConditionalInvocationExpressionHeadNullConditionalInvocationExpressionHead =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NullConditionalInvocationExpressionHead")

-- | DSL name token for hydra.ext.csharp.syntax.NullConditionalInvocationExpression
nullConditionalInvocationExpressionNullConditionalInvocationExpression :: Typed.TypedName Syntax.NullConditionalInvocationExpression
nullConditionalInvocationExpressionNullConditionalInvocationExpression =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NullConditionalInvocationExpression")

-- | DSL updater for the arguments field of hydra.ext.csharp.syntax.NullConditionalInvocationExpression
nullConditionalInvocationExpressionWithArguments :: Typed.TypedTerm Syntax.NullConditionalInvocationExpression -> Typed.TypedTerm (Maybe Syntax.ArgumentList) -> Typed.TypedTerm Syntax.NullConditionalInvocationExpression
nullConditionalInvocationExpressionWithArguments original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalInvocationExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "head"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalInvocationExpression"),
              Model.projectionFieldName = (Model.Name "head")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the head field of hydra.ext.csharp.syntax.NullConditionalInvocationExpression
nullConditionalInvocationExpressionWithHead :: Typed.TypedTerm Syntax.NullConditionalInvocationExpression -> Typed.TypedTerm Syntax.NullConditionalInvocationExpressionHead -> Typed.TypedTerm Syntax.NullConditionalInvocationExpression
nullConditionalInvocationExpressionWithHead original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalInvocationExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "head"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalInvocationExpression"),
              Model.projectionFieldName = (Model.Name "arguments")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.NullConditionalMemberAccess
nullConditionalMemberAccess :: Typed.TypedTerm Syntax.PrimaryExpression -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm [Syntax.DependentAccess] -> Typed.TypedTerm Syntax.NullConditionalMemberAccess
nullConditionalMemberAccess expression identifier typeArguments dependentAccess =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm expression)},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm identifier)},
        Model.Field {
          Model.fieldName = (Model.Name "typeArguments"),
          Model.fieldTerm = (Typed.unTypedTerm typeArguments)},
        Model.Field {
          Model.fieldName = (Model.Name "dependentAccess"),
          Model.fieldTerm = (Typed.unTypedTerm dependentAccess)}]}))

-- | DSL accessor for the dependentAccess field of hydra.ext.csharp.syntax.NullConditionalMemberAccess
nullConditionalMemberAccessDependentAccess :: Typed.TypedTerm Syntax.NullConditionalMemberAccess -> Typed.TypedTerm [Syntax.DependentAccess]
nullConditionalMemberAccessDependentAccess x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"),
        Model.projectionFieldName = (Model.Name "dependentAccess")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.NullConditionalMemberAccess
nullConditionalMemberAccessExpression :: Typed.TypedTerm Syntax.NullConditionalMemberAccess -> Typed.TypedTerm Syntax.PrimaryExpression
nullConditionalMemberAccessExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"),
        Model.projectionFieldName = (Model.Name "expression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.NullConditionalMemberAccess
nullConditionalMemberAccessIdentifier :: Typed.TypedTerm Syntax.NullConditionalMemberAccess -> Typed.TypedTerm Syntax.Identifier
nullConditionalMemberAccessIdentifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"),
        Model.projectionFieldName = (Model.Name "identifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.NullConditionalMemberAccess
nullConditionalMemberAccessNullConditionalMemberAccess :: Typed.TypedName Syntax.NullConditionalMemberAccess
nullConditionalMemberAccessNullConditionalMemberAccess =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess")

-- | DSL accessor for the typeArguments field of hydra.ext.csharp.syntax.NullConditionalMemberAccess
nullConditionalMemberAccessTypeArguments :: Typed.TypedTerm Syntax.NullConditionalMemberAccess -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList)
nullConditionalMemberAccessTypeArguments x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"),
        Model.projectionFieldName = (Model.Name "typeArguments")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the dependentAccess field of hydra.ext.csharp.syntax.NullConditionalMemberAccess
nullConditionalMemberAccessWithDependentAccess :: Typed.TypedTerm Syntax.NullConditionalMemberAccess -> Typed.TypedTerm [Syntax.DependentAccess] -> Typed.TypedTerm Syntax.NullConditionalMemberAccess
nullConditionalMemberAccessWithDependentAccess original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeArguments"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"),
              Model.projectionFieldName = (Model.Name "typeArguments")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dependentAccess"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the expression field of hydra.ext.csharp.syntax.NullConditionalMemberAccess
nullConditionalMemberAccessWithExpression :: Typed.TypedTerm Syntax.NullConditionalMemberAccess -> Typed.TypedTerm Syntax.PrimaryExpression -> Typed.TypedTerm Syntax.NullConditionalMemberAccess
nullConditionalMemberAccessWithExpression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeArguments"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"),
              Model.projectionFieldName = (Model.Name "typeArguments")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dependentAccess"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"),
              Model.projectionFieldName = (Model.Name "dependentAccess")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.NullConditionalMemberAccess
nullConditionalMemberAccessWithIdentifier :: Typed.TypedTerm Syntax.NullConditionalMemberAccess -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.NullConditionalMemberAccess
nullConditionalMemberAccessWithIdentifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "typeArguments"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"),
              Model.projectionFieldName = (Model.Name "typeArguments")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dependentAccess"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"),
              Model.projectionFieldName = (Model.Name "dependentAccess")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the typeArguments field of hydra.ext.csharp.syntax.NullConditionalMemberAccess
nullConditionalMemberAccessWithTypeArguments :: Typed.TypedTerm Syntax.NullConditionalMemberAccess -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.NullConditionalMemberAccess
nullConditionalMemberAccessWithTypeArguments original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeArguments"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "dependentAccess"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalMemberAccess"),
              Model.projectionFieldName = (Model.Name "dependentAccess")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.NullConditionalProjectionInitializer
nullConditionalProjectionInitializer :: Typed.TypedTerm Syntax.PrimaryExpression -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.NullConditionalProjectionInitializer
nullConditionalProjectionInitializer expression identifier typeArguments =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalProjectionInitializer"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm expression)},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm identifier)},
        Model.Field {
          Model.fieldName = (Model.Name "typeArguments"),
          Model.fieldTerm = (Typed.unTypedTerm typeArguments)}]}))

-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.NullConditionalProjectionInitializer
nullConditionalProjectionInitializerExpression :: Typed.TypedTerm Syntax.NullConditionalProjectionInitializer -> Typed.TypedTerm Syntax.PrimaryExpression
nullConditionalProjectionInitializerExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalProjectionInitializer"),
        Model.projectionFieldName = (Model.Name "expression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.NullConditionalProjectionInitializer
nullConditionalProjectionInitializerIdentifier :: Typed.TypedTerm Syntax.NullConditionalProjectionInitializer -> Typed.TypedTerm Syntax.Identifier
nullConditionalProjectionInitializerIdentifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalProjectionInitializer"),
        Model.projectionFieldName = (Model.Name "identifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.NullConditionalProjectionInitializer
nullConditionalProjectionInitializerNullConditionalProjectionInitializer :: Typed.TypedName Syntax.NullConditionalProjectionInitializer
nullConditionalProjectionInitializerNullConditionalProjectionInitializer =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NullConditionalProjectionInitializer")

-- | DSL accessor for the typeArguments field of hydra.ext.csharp.syntax.NullConditionalProjectionInitializer
nullConditionalProjectionInitializerTypeArguments :: Typed.TypedTerm Syntax.NullConditionalProjectionInitializer -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList)
nullConditionalProjectionInitializerTypeArguments x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalProjectionInitializer"),
        Model.projectionFieldName = (Model.Name "typeArguments")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the expression field of hydra.ext.csharp.syntax.NullConditionalProjectionInitializer
nullConditionalProjectionInitializerWithExpression :: Typed.TypedTerm Syntax.NullConditionalProjectionInitializer -> Typed.TypedTerm Syntax.PrimaryExpression -> Typed.TypedTerm Syntax.NullConditionalProjectionInitializer
nullConditionalProjectionInitializerWithExpression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalProjectionInitializer"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalProjectionInitializer"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeArguments"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalProjectionInitializer"),
              Model.projectionFieldName = (Model.Name "typeArguments")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.NullConditionalProjectionInitializer
nullConditionalProjectionInitializerWithIdentifier :: Typed.TypedTerm Syntax.NullConditionalProjectionInitializer -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.NullConditionalProjectionInitializer
nullConditionalProjectionInitializerWithIdentifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalProjectionInitializer"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalProjectionInitializer"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "typeArguments"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalProjectionInitializer"),
              Model.projectionFieldName = (Model.Name "typeArguments")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the typeArguments field of hydra.ext.csharp.syntax.NullConditionalProjectionInitializer
nullConditionalProjectionInitializerWithTypeArguments :: Typed.TypedTerm Syntax.NullConditionalProjectionInitializer -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.NullConditionalProjectionInitializer
nullConditionalProjectionInitializerWithTypeArguments original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalProjectionInitializer"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalProjectionInitializer"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NullConditionalProjectionInitializer"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeArguments"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the decimal variant of hydra.ext.csharp.syntax.NumericType
numericTypeDecimal :: Typed.TypedTerm Syntax.NumericType
numericTypeDecimal =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NumericType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "decimal"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the floatingPoint variant of hydra.ext.csharp.syntax.NumericType
numericTypeFloatingPoint :: Typed.TypedTerm Syntax.FloatingPointType -> Typed.TypedTerm Syntax.NumericType
numericTypeFloatingPoint x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NumericType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "floatingPoint"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the integral variant of hydra.ext.csharp.syntax.NumericType
numericTypeIntegral :: Typed.TypedTerm Syntax.IntegralType -> Typed.TypedTerm Syntax.NumericType
numericTypeIntegral x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.NumericType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "integral"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.NumericType
numericTypeNumericType :: Typed.TypedName Syntax.NumericType
numericTypeNumericType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.NumericType")

-- | DSL constructor for hydra.ext.csharp.syntax.ObjectCreationExpression
objectCreationExpression :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm (Maybe Syntax.ArgumentList) -> Typed.TypedTerm (Maybe Syntax.ObjectOrCollectionInitializer) -> Typed.TypedTerm Syntax.ObjectCreationExpression
objectCreationExpression type_ arguments initializer =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ObjectCreationExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Typed.unTypedTerm arguments)},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Typed.unTypedTerm initializer)}]}))

-- | DSL accessor for the arguments field of hydra.ext.csharp.syntax.ObjectCreationExpression
objectCreationExpressionArguments :: Typed.TypedTerm Syntax.ObjectCreationExpression -> Typed.TypedTerm (Maybe Syntax.ArgumentList)
objectCreationExpressionArguments x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ObjectCreationExpression"),
        Model.projectionFieldName = (Model.Name "arguments")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the initializer field of hydra.ext.csharp.syntax.ObjectCreationExpression
objectCreationExpressionInitializer :: Typed.TypedTerm Syntax.ObjectCreationExpression -> Typed.TypedTerm (Maybe Syntax.ObjectOrCollectionInitializer)
objectCreationExpressionInitializer x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ObjectCreationExpression"),
        Model.projectionFieldName = (Model.Name "initializer")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.ObjectCreationExpression
objectCreationExpressionObjectCreationExpression :: Typed.TypedName Syntax.ObjectCreationExpression
objectCreationExpressionObjectCreationExpression =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ObjectCreationExpression")

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.ObjectCreationExpression
objectCreationExpressionType :: Typed.TypedTerm Syntax.ObjectCreationExpression -> Typed.TypedTerm Syntax.Type
objectCreationExpressionType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ObjectCreationExpression"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the arguments field of hydra.ext.csharp.syntax.ObjectCreationExpression
objectCreationExpressionWithArguments :: Typed.TypedTerm Syntax.ObjectCreationExpression -> Typed.TypedTerm (Maybe Syntax.ArgumentList) -> Typed.TypedTerm Syntax.ObjectCreationExpression
objectCreationExpressionWithArguments original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ObjectCreationExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ObjectCreationExpression"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ObjectCreationExpression"),
              Model.projectionFieldName = (Model.Name "initializer")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the initializer field of hydra.ext.csharp.syntax.ObjectCreationExpression
objectCreationExpressionWithInitializer :: Typed.TypedTerm Syntax.ObjectCreationExpression -> Typed.TypedTerm (Maybe Syntax.ObjectOrCollectionInitializer) -> Typed.TypedTerm Syntax.ObjectCreationExpression
objectCreationExpressionWithInitializer original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ObjectCreationExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ObjectCreationExpression"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ObjectCreationExpression"),
              Model.projectionFieldName = (Model.Name "arguments")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.ObjectCreationExpression
objectCreationExpressionWithType :: Typed.TypedTerm Syntax.ObjectCreationExpression -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ObjectCreationExpression
objectCreationExpressionWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ObjectCreationExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ObjectCreationExpression"),
              Model.projectionFieldName = (Model.Name "arguments")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ObjectCreationExpression"),
              Model.projectionFieldName = (Model.Name "initializer")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the collection variant of hydra.ext.csharp.syntax.ObjectOrCollectionInitializer
objectOrCollectionInitializerCollection :: Typed.TypedTerm [Syntax.ElementInitializer] -> Typed.TypedTerm Syntax.ObjectOrCollectionInitializer
objectOrCollectionInitializerCollection x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ObjectOrCollectionInitializer"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "collection"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the object variant of hydra.ext.csharp.syntax.ObjectOrCollectionInitializer
objectOrCollectionInitializerObject :: Typed.TypedTerm [Syntax.MemberInitializer] -> Typed.TypedTerm Syntax.ObjectOrCollectionInitializer
objectOrCollectionInitializerObject x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ObjectOrCollectionInitializer"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "object"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.ObjectOrCollectionInitializer
objectOrCollectionInitializerObjectOrCollectionInitializer :: Typed.TypedName Syntax.ObjectOrCollectionInitializer
objectOrCollectionInitializerObjectOrCollectionInitializer =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ObjectOrCollectionInitializer")

-- | DSL injection for the block variant of hydra.ext.csharp.syntax.OperatorBody
operatorBodyBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.OperatorBody
operatorBodyBlock x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "block"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the empty variant of hydra.ext.csharp.syntax.OperatorBody
operatorBodyEmpty :: Typed.TypedTerm Syntax.OperatorBody
operatorBodyEmpty =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "empty"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.OperatorBody
operatorBodyExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.OperatorBody
operatorBodyExpression x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "expression"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.OperatorBody
operatorBodyOperatorBody :: Typed.TypedName Syntax.OperatorBody
operatorBodyOperatorBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.OperatorBody")

-- | DSL constructor for hydra.ext.csharp.syntax.OperatorDeclaration
operatorDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.OperatorModifier] -> Typed.TypedTerm Syntax.OperatorDeclarator -> Typed.TypedTerm Syntax.OperatorBody -> Typed.TypedTerm Syntax.OperatorDeclaration
operatorDeclaration attributes modifiers declarator body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm modifiers)},
        Model.Field {
          Model.fieldName = (Model.Name "declarator"),
          Model.fieldTerm = (Typed.unTypedTerm declarator)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.OperatorDeclaration
operatorDeclarationAttributes :: Typed.TypedTerm Syntax.OperatorDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes)
operatorDeclarationAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.OperatorDeclaration
operatorDeclarationBody :: Typed.TypedTerm Syntax.OperatorDeclaration -> Typed.TypedTerm Syntax.OperatorBody
operatorDeclarationBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the declarator field of hydra.ext.csharp.syntax.OperatorDeclaration
operatorDeclarationDeclarator :: Typed.TypedTerm Syntax.OperatorDeclaration -> Typed.TypedTerm Syntax.OperatorDeclarator
operatorDeclarationDeclarator x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"),
        Model.projectionFieldName = (Model.Name "declarator")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.OperatorDeclaration
operatorDeclarationModifiers :: Typed.TypedTerm Syntax.OperatorDeclaration -> Typed.TypedTerm [Syntax.OperatorModifier]
operatorDeclarationModifiers x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"),
        Model.projectionFieldName = (Model.Name "modifiers")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.OperatorDeclaration
operatorDeclarationOperatorDeclaration :: Typed.TypedName Syntax.OperatorDeclaration
operatorDeclarationOperatorDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration")

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.OperatorDeclaration
operatorDeclarationWithAttributes :: Typed.TypedTerm Syntax.OperatorDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.OperatorDeclaration
operatorDeclarationWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"),
              Model.projectionFieldName = (Model.Name "declarator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the body field of hydra.ext.csharp.syntax.OperatorDeclaration
operatorDeclarationWithBody :: Typed.TypedTerm Syntax.OperatorDeclaration -> Typed.TypedTerm Syntax.OperatorBody -> Typed.TypedTerm Syntax.OperatorDeclaration
operatorDeclarationWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"),
              Model.projectionFieldName = (Model.Name "declarator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the declarator field of hydra.ext.csharp.syntax.OperatorDeclaration
operatorDeclarationWithDeclarator :: Typed.TypedTerm Syntax.OperatorDeclaration -> Typed.TypedTerm Syntax.OperatorDeclarator -> Typed.TypedTerm Syntax.OperatorDeclaration
operatorDeclarationWithDeclarator original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarator"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.OperatorDeclaration
operatorDeclarationWithModifiers :: Typed.TypedTerm Syntax.OperatorDeclaration -> Typed.TypedTerm [Syntax.OperatorModifier] -> Typed.TypedTerm Syntax.OperatorDeclaration
operatorDeclarationWithModifiers original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "declarator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"),
              Model.projectionFieldName = (Model.Name "declarator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the binary variant of hydra.ext.csharp.syntax.OperatorDeclarator
operatorDeclaratorBinary :: Typed.TypedTerm Syntax.BinaryOperatorDeclarator -> Typed.TypedTerm Syntax.OperatorDeclarator
operatorDeclaratorBinary x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclarator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "binary"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the conversion variant of hydra.ext.csharp.syntax.OperatorDeclarator
operatorDeclaratorConversion :: Typed.TypedTerm Syntax.ConversionOperatorDeclarator -> Typed.TypedTerm Syntax.OperatorDeclarator
operatorDeclaratorConversion x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclarator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "conversion"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.OperatorDeclarator
operatorDeclaratorOperatorDeclarator :: Typed.TypedName Syntax.OperatorDeclarator
operatorDeclaratorOperatorDeclarator = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.OperatorDeclarator")

-- | DSL injection for the unary variant of hydra.ext.csharp.syntax.OperatorDeclarator
operatorDeclaratorUnary :: Typed.TypedTerm Syntax.UnaryOperatorDeclarator -> Typed.TypedTerm Syntax.OperatorDeclarator
operatorDeclaratorUnary x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorDeclarator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "unary"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the extern variant of hydra.ext.csharp.syntax.OperatorModifier
operatorModifierExtern :: Typed.TypedTerm Syntax.OperatorModifier
operatorModifierExtern =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "extern"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.csharp.syntax.OperatorModifier
operatorModifierOperatorModifier :: Typed.TypedName Syntax.OperatorModifier
operatorModifierOperatorModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.OperatorModifier")

-- | DSL injection for the public variant of hydra.ext.csharp.syntax.OperatorModifier
operatorModifierPublic :: Typed.TypedTerm Syntax.OperatorModifier
operatorModifierPublic =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "public"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the static variant of hydra.ext.csharp.syntax.OperatorModifier
operatorModifierStatic :: Typed.TypedTerm Syntax.OperatorModifier
operatorModifierStatic =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "static"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the unsafe variant of hydra.ext.csharp.syntax.OperatorModifier
operatorModifierUnsafe :: Typed.TypedTerm Syntax.OperatorModifier
operatorModifierUnsafe =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OperatorModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "unsafe"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL constructor for hydra.ext.csharp.syntax.Ordering
ordering :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm (Maybe Syntax.OrderingDirection) -> Typed.TypedTerm Syntax.Ordering
ordering expression direction =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.Ordering"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm expression)},
        Model.Field {
          Model.fieldName = (Model.Name "direction"),
          Model.fieldTerm = (Typed.unTypedTerm direction)}]}))

-- | DSL accessor for the direction field of hydra.ext.csharp.syntax.Ordering
orderingDirection :: Typed.TypedTerm Syntax.Ordering -> Typed.TypedTerm (Maybe Syntax.OrderingDirection)
orderingDirection x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Ordering"),
        Model.projectionFieldName = (Model.Name "direction")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL injection for the ascending variant of hydra.ext.csharp.syntax.OrderingDirection
orderingDirectionAscending :: Typed.TypedTerm Syntax.OrderingDirection
orderingDirectionAscending =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OrderingDirection"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "ascending"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the descending variant of hydra.ext.csharp.syntax.OrderingDirection
orderingDirectionDescending :: Typed.TypedTerm Syntax.OrderingDirection
orderingDirectionDescending =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OrderingDirection"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "descending"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.csharp.syntax.OrderingDirection
orderingDirectionOrderingDirection :: Typed.TypedName Syntax.OrderingDirection
orderingDirectionOrderingDirection = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.OrderingDirection")

-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.Ordering
orderingExpression :: Typed.TypedTerm Syntax.Ordering -> Typed.TypedTerm Syntax.Expression
orderingExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Ordering"),
        Model.projectionFieldName = (Model.Name "expression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.Ordering
orderingOrdering :: Typed.TypedName Syntax.Ordering
orderingOrdering = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.Ordering")

-- | DSL updater for the direction field of hydra.ext.csharp.syntax.Ordering
orderingWithDirection :: Typed.TypedTerm Syntax.Ordering -> Typed.TypedTerm (Maybe Syntax.OrderingDirection) -> Typed.TypedTerm Syntax.Ordering
orderingWithDirection original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.Ordering"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Ordering"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "direction"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the expression field of hydra.ext.csharp.syntax.Ordering
orderingWithExpression :: Typed.TypedTerm Syntax.Ordering -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Ordering
orderingWithExpression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.Ordering"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "direction"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Ordering"),
              Model.projectionFieldName = (Model.Name "direction")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the add variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator
overloadableBinaryOperatorAdd :: Typed.TypedTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorAdd =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "add"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the and variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator
overloadableBinaryOperatorAnd :: Typed.TypedTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorAnd =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "and"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the divide variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator
overloadableBinaryOperatorDivide :: Typed.TypedTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorDivide =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "divide"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the equal variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator
overloadableBinaryOperatorEqual :: Typed.TypedTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorEqual =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "equal"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the greaterThan variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator
overloadableBinaryOperatorGreaterThan :: Typed.TypedTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorGreaterThan =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "greaterThan"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the greaterThanOrEqual variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator
overloadableBinaryOperatorGreaterThanOrEqual :: Typed.TypedTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorGreaterThanOrEqual =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "greaterThanOrEqual"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the leftShift variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator
overloadableBinaryOperatorLeftShift :: Typed.TypedTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorLeftShift =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "leftShift"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the lessThan variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator
overloadableBinaryOperatorLessThan :: Typed.TypedTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorLessThan =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "lessThan"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the lessThanOrEqual variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator
overloadableBinaryOperatorLessThanOrEqual :: Typed.TypedTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorLessThanOrEqual =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "lessThanOrEqual"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the modulus variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator
overloadableBinaryOperatorModulus :: Typed.TypedTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorModulus =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "modulus"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the multiply variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator
overloadableBinaryOperatorMultiply :: Typed.TypedTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorMultiply =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "multiply"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the notEqual variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator
overloadableBinaryOperatorNotEqual :: Typed.TypedTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorNotEqual =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "notEqual"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the or variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator
overloadableBinaryOperatorOr :: Typed.TypedTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorOr =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "or"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.csharp.syntax.OverloadableBinaryOperator
overloadableBinaryOperatorOverloadableBinaryOperator :: Typed.TypedName Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorOverloadableBinaryOperator =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator")

-- | DSL injection for the rightShift variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator
overloadableBinaryOperatorRightShift :: Typed.TypedTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorRightShift =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "rightShift"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the subtract variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator
overloadableBinaryOperatorSubtract :: Typed.TypedTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorSubtract =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "subtract"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the xor variant of hydra.ext.csharp.syntax.OverloadableBinaryOperator
overloadableBinaryOperatorXor :: Typed.TypedTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorXor =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableBinaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "xor"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the complement variant of hydra.ext.csharp.syntax.OverloadableUnaryOperator
overloadableUnaryOperatorComplement :: Typed.TypedTerm Syntax.OverloadableUnaryOperator
overloadableUnaryOperatorComplement =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableUnaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "complement"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the decrement variant of hydra.ext.csharp.syntax.OverloadableUnaryOperator
overloadableUnaryOperatorDecrement :: Typed.TypedTerm Syntax.OverloadableUnaryOperator
overloadableUnaryOperatorDecrement =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableUnaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "decrement"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the false variant of hydra.ext.csharp.syntax.OverloadableUnaryOperator
overloadableUnaryOperatorFalse :: Typed.TypedTerm Syntax.OverloadableUnaryOperator
overloadableUnaryOperatorFalse =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableUnaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "false"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the increment variant of hydra.ext.csharp.syntax.OverloadableUnaryOperator
overloadableUnaryOperatorIncrement :: Typed.TypedTerm Syntax.OverloadableUnaryOperator
overloadableUnaryOperatorIncrement =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableUnaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "increment"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the minus variant of hydra.ext.csharp.syntax.OverloadableUnaryOperator
overloadableUnaryOperatorMinus :: Typed.TypedTerm Syntax.OverloadableUnaryOperator
overloadableUnaryOperatorMinus =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableUnaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "minus"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the not variant of hydra.ext.csharp.syntax.OverloadableUnaryOperator
overloadableUnaryOperatorNot :: Typed.TypedTerm Syntax.OverloadableUnaryOperator
overloadableUnaryOperatorNot =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableUnaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "not"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.csharp.syntax.OverloadableUnaryOperator
overloadableUnaryOperatorOverloadableUnaryOperator :: Typed.TypedName Syntax.OverloadableUnaryOperator
overloadableUnaryOperatorOverloadableUnaryOperator =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.OverloadableUnaryOperator")

-- | DSL injection for the plus variant of hydra.ext.csharp.syntax.OverloadableUnaryOperator
overloadableUnaryOperatorPlus :: Typed.TypedTerm Syntax.OverloadableUnaryOperator
overloadableUnaryOperatorPlus =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableUnaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "plus"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the true variant of hydra.ext.csharp.syntax.OverloadableUnaryOperator
overloadableUnaryOperatorTrue :: Typed.TypedTerm Syntax.OverloadableUnaryOperator
overloadableUnaryOperatorTrue =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.OverloadableUnaryOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "true"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL constructor for hydra.ext.csharp.syntax.ParameterArray
parameterArray :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ParameterArray
parameterArray attributes type_ identifier =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterArray"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm identifier)}]}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.ParameterArray
parameterArrayAttributes :: Typed.TypedTerm Syntax.ParameterArray -> Typed.TypedTerm (Maybe Syntax.Attributes)
parameterArrayAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterArray"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.ParameterArray
parameterArrayIdentifier :: Typed.TypedTerm Syntax.ParameterArray -> Typed.TypedTerm Syntax.Identifier
parameterArrayIdentifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterArray"),
        Model.projectionFieldName = (Model.Name "identifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.ParameterArray
parameterArrayParameterArray :: Typed.TypedName Syntax.ParameterArray
parameterArrayParameterArray = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ParameterArray")

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.ParameterArray
parameterArrayType :: Typed.TypedTerm Syntax.ParameterArray -> Typed.TypedTerm Syntax.ArrayType
parameterArrayType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterArray"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.ParameterArray
parameterArrayWithAttributes :: Typed.TypedTerm Syntax.ParameterArray -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.ParameterArray
parameterArrayWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterArray"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterArray"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterArray"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.ParameterArray
parameterArrayWithIdentifier :: Typed.TypedTerm Syntax.ParameterArray -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.ParameterArray
parameterArrayWithIdentifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterArray"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterArray"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterArray"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.ParameterArray
parameterArrayWithType :: Typed.TypedTerm Syntax.ParameterArray -> Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm Syntax.ParameterArray
parameterArrayWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterArray"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterArray"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterArray"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the in variant of hydra.ext.csharp.syntax.ParameterModeModifier
parameterModeModifierIn :: Typed.TypedTerm Syntax.ParameterModeModifier
parameterModeModifierIn =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterModeModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "in"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the out variant of hydra.ext.csharp.syntax.ParameterModeModifier
parameterModeModifierOut :: Typed.TypedTerm Syntax.ParameterModeModifier
parameterModeModifierOut =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterModeModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "out"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.csharp.syntax.ParameterModeModifier
parameterModeModifierParameterModeModifier :: Typed.TypedName Syntax.ParameterModeModifier
parameterModeModifierParameterModeModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ParameterModeModifier")

-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.ParameterModeModifier
parameterModeModifierRef :: Typed.TypedTerm Syntax.ParameterModeModifier
parameterModeModifierRef =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterModeModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "ref"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the mode variant of hydra.ext.csharp.syntax.ParameterModifier
parameterModifierMode :: Typed.TypedTerm Syntax.ParameterModeModifier -> Typed.TypedTerm Syntax.ParameterModifier
parameterModifierMode x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "mode"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.ParameterModifier
parameterModifierParameterModifier :: Typed.TypedName Syntax.ParameterModifier
parameterModifierParameterModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ParameterModifier")

-- | DSL injection for the this variant of hydra.ext.csharp.syntax.ParameterModifier
parameterModifierThis :: Typed.TypedTerm Syntax.ParameterModifier
parameterModifierThis =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ParameterModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "this"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the constant variant of hydra.ext.csharp.syntax.Pattern
patternConstant :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Pattern
patternConstant x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Pattern"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "constant"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the declaration variant of hydra.ext.csharp.syntax.Pattern
patternDeclaration :: Typed.TypedTerm Syntax.DeclarationPattern -> Typed.TypedTerm Syntax.Pattern
patternDeclaration x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Pattern"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "declaration"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.Pattern
patternPattern :: Typed.TypedName Syntax.Pattern
patternPattern = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.Pattern")

-- | DSL injection for the var variant of hydra.ext.csharp.syntax.Pattern
patternVar :: Typed.TypedTerm Syntax.Designation -> Typed.TypedTerm Syntax.Pattern
patternVar x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Pattern"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "var"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.csharp.syntax.PointerElementAccess
pointerElementAccess :: Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.PointerElementAccess
pointerElementAccess pointer index =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerElementAccess"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "pointer"),
          Model.fieldTerm = (Typed.unTypedTerm pointer)},
        Model.Field {
          Model.fieldName = (Model.Name "index"),
          Model.fieldTerm = (Typed.unTypedTerm index)}]}))

-- | DSL accessor for the index field of hydra.ext.csharp.syntax.PointerElementAccess
pointerElementAccessIndex :: Typed.TypedTerm Syntax.PointerElementAccess -> Typed.TypedTerm Syntax.Expression
pointerElementAccessIndex x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerElementAccess"),
        Model.projectionFieldName = (Model.Name "index")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the pointer field of hydra.ext.csharp.syntax.PointerElementAccess
pointerElementAccessPointer :: Typed.TypedTerm Syntax.PointerElementAccess -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression
pointerElementAccessPointer x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerElementAccess"),
        Model.projectionFieldName = (Model.Name "pointer")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.PointerElementAccess
pointerElementAccessPointerElementAccess :: Typed.TypedName Syntax.PointerElementAccess
pointerElementAccessPointerElementAccess = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.PointerElementAccess")

-- | DSL updater for the index field of hydra.ext.csharp.syntax.PointerElementAccess
pointerElementAccessWithIndex :: Typed.TypedTerm Syntax.PointerElementAccess -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.PointerElementAccess
pointerElementAccessWithIndex original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerElementAccess"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "pointer"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerElementAccess"),
              Model.projectionFieldName = (Model.Name "pointer")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "index"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the pointer field of hydra.ext.csharp.syntax.PointerElementAccess
pointerElementAccessWithPointer :: Typed.TypedTerm Syntax.PointerElementAccess -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression -> Typed.TypedTerm Syntax.PointerElementAccess
pointerElementAccessWithPointer original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerElementAccess"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "pointer"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "index"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerElementAccess"),
              Model.projectionFieldName = (Model.Name "index")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.PointerMemberAccess
pointerMemberAccess :: Typed.TypedTerm Syntax.PrimaryExpression -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.PointerMemberAccess
pointerMemberAccess pointer member typeArguments =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerMemberAccess"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "pointer"),
          Model.fieldTerm = (Typed.unTypedTerm pointer)},
        Model.Field {
          Model.fieldName = (Model.Name "member"),
          Model.fieldTerm = (Typed.unTypedTerm member)},
        Model.Field {
          Model.fieldName = (Model.Name "typeArguments"),
          Model.fieldTerm = (Typed.unTypedTerm typeArguments)}]}))

-- | DSL accessor for the member field of hydra.ext.csharp.syntax.PointerMemberAccess
pointerMemberAccessMember :: Typed.TypedTerm Syntax.PointerMemberAccess -> Typed.TypedTerm Syntax.Identifier
pointerMemberAccessMember x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerMemberAccess"),
        Model.projectionFieldName = (Model.Name "member")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the pointer field of hydra.ext.csharp.syntax.PointerMemberAccess
pointerMemberAccessPointer :: Typed.TypedTerm Syntax.PointerMemberAccess -> Typed.TypedTerm Syntax.PrimaryExpression
pointerMemberAccessPointer x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerMemberAccess"),
        Model.projectionFieldName = (Model.Name "pointer")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.PointerMemberAccess
pointerMemberAccessPointerMemberAccess :: Typed.TypedName Syntax.PointerMemberAccess
pointerMemberAccessPointerMemberAccess = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.PointerMemberAccess")

-- | DSL accessor for the typeArguments field of hydra.ext.csharp.syntax.PointerMemberAccess
pointerMemberAccessTypeArguments :: Typed.TypedTerm Syntax.PointerMemberAccess -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList)
pointerMemberAccessTypeArguments x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerMemberAccess"),
        Model.projectionFieldName = (Model.Name "typeArguments")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the member field of hydra.ext.csharp.syntax.PointerMemberAccess
pointerMemberAccessWithMember :: Typed.TypedTerm Syntax.PointerMemberAccess -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.PointerMemberAccess
pointerMemberAccessWithMember original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerMemberAccess"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "pointer"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerMemberAccess"),
              Model.projectionFieldName = (Model.Name "pointer")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "member"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "typeArguments"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerMemberAccess"),
              Model.projectionFieldName = (Model.Name "typeArguments")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the pointer field of hydra.ext.csharp.syntax.PointerMemberAccess
pointerMemberAccessWithPointer :: Typed.TypedTerm Syntax.PointerMemberAccess -> Typed.TypedTerm Syntax.PrimaryExpression -> Typed.TypedTerm Syntax.PointerMemberAccess
pointerMemberAccessWithPointer original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerMemberAccess"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "pointer"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "member"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerMemberAccess"),
              Model.projectionFieldName = (Model.Name "member")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeArguments"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerMemberAccess"),
              Model.projectionFieldName = (Model.Name "typeArguments")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the typeArguments field of hydra.ext.csharp.syntax.PointerMemberAccess
pointerMemberAccessWithTypeArguments :: Typed.TypedTerm Syntax.PointerMemberAccess -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.PointerMemberAccess
pointerMemberAccessWithTypeArguments original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerMemberAccess"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "pointer"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerMemberAccess"),
              Model.projectionFieldName = (Model.Name "pointer")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "member"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerMemberAccess"),
              Model.projectionFieldName = (Model.Name "member")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeArguments"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the pointerDepth variant of hydra.ext.csharp.syntax.PointerType
pointerTypePointerDepth :: Typed.TypedTerm Int -> Typed.TypedTerm Syntax.PointerType
pointerTypePointerDepth x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "pointerDepth"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.PointerType
pointerTypePointerType :: Typed.TypedName Syntax.PointerType
pointerTypePointerType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.PointerType")

-- | DSL injection for the valueType variant of hydra.ext.csharp.syntax.PointerType
pointerTypeValueType :: Typed.TypedTerm (Maybe Syntax.ValueType) -> Typed.TypedTerm Syntax.PointerType
pointerTypeValueType x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PointerType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "valueType"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.csharp.syntax.PositionalArgument
positionalArgument :: Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.AttributeArgumentExpression -> Typed.TypedTerm Syntax.PositionalArgument
positionalArgument name value =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.PositionalArgument"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Typed.unTypedTerm value)}]}))

-- | DSL constructor for the hydra.ext.csharp.syntax.PositionalArgumentList wrapper
positionalArgumentList :: Typed.TypedTerm [Syntax.PositionalArgument] -> Typed.TypedTerm Syntax.PositionalArgumentList
positionalArgumentList x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.PositionalArgumentList"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.PositionalArgumentList
positionalArgumentListPositionalArgumentList :: Typed.TypedName Syntax.PositionalArgumentList
positionalArgumentListPositionalArgumentList =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.PositionalArgumentList")

-- | DSL accessor for the name field of hydra.ext.csharp.syntax.PositionalArgument
positionalArgumentName :: Typed.TypedTerm Syntax.PositionalArgument -> Typed.TypedTerm (Maybe Syntax.Identifier)
positionalArgumentName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PositionalArgument"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.PositionalArgument
positionalArgumentPositionalArgument :: Typed.TypedName Syntax.PositionalArgument
positionalArgumentPositionalArgument = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.PositionalArgument")

-- | DSL accessor for the value field of hydra.ext.csharp.syntax.PositionalArgument
positionalArgumentValue :: Typed.TypedTerm Syntax.PositionalArgument -> Typed.TypedTerm Syntax.AttributeArgumentExpression
positionalArgumentValue x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PositionalArgument"),
        Model.projectionFieldName = (Model.Name "value")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the name field of hydra.ext.csharp.syntax.PositionalArgument
positionalArgumentWithName :: Typed.TypedTerm Syntax.PositionalArgument -> Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.PositionalArgument
positionalArgumentWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.PositionalArgument"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PositionalArgument"),
              Model.projectionFieldName = (Model.Name "value")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the value field of hydra.ext.csharp.syntax.PositionalArgument
positionalArgumentWithValue :: Typed.TypedTerm Syntax.PositionalArgument -> Typed.TypedTerm Syntax.AttributeArgumentExpression -> Typed.TypedTerm Syntax.PositionalArgument
positionalArgumentWithValue original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.PositionalArgument"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PositionalArgument"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the bool variant of hydra.ext.csharp.syntax.PredefinedType
predefinedTypeBool :: Typed.TypedTerm Syntax.PredefinedType
predefinedTypeBool =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PredefinedType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "bool"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the byte variant of hydra.ext.csharp.syntax.PredefinedType
predefinedTypeByte :: Typed.TypedTerm Syntax.PredefinedType
predefinedTypeByte =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PredefinedType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "byte"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the char variant of hydra.ext.csharp.syntax.PredefinedType
predefinedTypeChar :: Typed.TypedTerm Syntax.PredefinedType
predefinedTypeChar =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PredefinedType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "char"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the decimal variant of hydra.ext.csharp.syntax.PredefinedType
predefinedTypeDecimal :: Typed.TypedTerm Syntax.PredefinedType
predefinedTypeDecimal =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PredefinedType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "decimal"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the double variant of hydra.ext.csharp.syntax.PredefinedType
predefinedTypeDouble :: Typed.TypedTerm Syntax.PredefinedType
predefinedTypeDouble =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PredefinedType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "double"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the float variant of hydra.ext.csharp.syntax.PredefinedType
predefinedTypeFloat :: Typed.TypedTerm Syntax.PredefinedType
predefinedTypeFloat =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PredefinedType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "float"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the int variant of hydra.ext.csharp.syntax.PredefinedType
predefinedTypeInt :: Typed.TypedTerm Syntax.PredefinedType
predefinedTypeInt =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PredefinedType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "int"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the long variant of hydra.ext.csharp.syntax.PredefinedType
predefinedTypeLong :: Typed.TypedTerm Syntax.PredefinedType
predefinedTypeLong =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PredefinedType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "long"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the object variant of hydra.ext.csharp.syntax.PredefinedType
predefinedTypeObject :: Typed.TypedTerm Syntax.PredefinedType
predefinedTypeObject =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PredefinedType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "object"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.csharp.syntax.PredefinedType
predefinedTypePredefinedType :: Typed.TypedName Syntax.PredefinedType
predefinedTypePredefinedType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.PredefinedType")

-- | DSL injection for the sbyte variant of hydra.ext.csharp.syntax.PredefinedType
predefinedTypeSbyte :: Typed.TypedTerm Syntax.PredefinedType
predefinedTypeSbyte =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PredefinedType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "sbyte"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the short variant of hydra.ext.csharp.syntax.PredefinedType
predefinedTypeShort :: Typed.TypedTerm Syntax.PredefinedType
predefinedTypeShort =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PredefinedType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "short"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the string variant of hydra.ext.csharp.syntax.PredefinedType
predefinedTypeString :: Typed.TypedTerm Syntax.PredefinedType
predefinedTypeString =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PredefinedType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "string"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the uint variant of hydra.ext.csharp.syntax.PredefinedType
predefinedTypeUint :: Typed.TypedTerm Syntax.PredefinedType
predefinedTypeUint =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PredefinedType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "uint"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the ulong variant of hydra.ext.csharp.syntax.PredefinedType
predefinedTypeUlong :: Typed.TypedTerm Syntax.PredefinedType
predefinedTypeUlong =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PredefinedType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "ulong"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the ushort variant of hydra.ext.csharp.syntax.PredefinedType
predefinedTypeUshort :: Typed.TypedTerm Syntax.PredefinedType
predefinedTypeUshort =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PredefinedType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "ushort"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the class variant of hydra.ext.csharp.syntax.PrimaryConstraint
primaryConstraintClass :: Typed.TypedTerm Syntax.PrimaryConstraint
primaryConstraintClass =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "class"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the classType variant of hydra.ext.csharp.syntax.PrimaryConstraint
primaryConstraintClassType :: Typed.TypedTerm Syntax.ClassType -> Typed.TypedTerm Syntax.PrimaryConstraint
primaryConstraintClassType x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "classType"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.PrimaryConstraint
primaryConstraintPrimaryConstraint :: Typed.TypedName Syntax.PrimaryConstraint
primaryConstraintPrimaryConstraint = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.PrimaryConstraint")

-- | DSL injection for the struct variant of hydra.ext.csharp.syntax.PrimaryConstraint
primaryConstraintStruct :: Typed.TypedTerm Syntax.PrimaryConstraint
primaryConstraintStruct =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "struct"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the unmanaged variant of hydra.ext.csharp.syntax.PrimaryConstraint
primaryConstraintUnmanaged :: Typed.TypedTerm Syntax.PrimaryConstraint
primaryConstraintUnmanaged =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "unmanaged"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the array variant of hydra.ext.csharp.syntax.PrimaryExpression
primaryExpressionArray :: Typed.TypedTerm Syntax.ArrayCreationExpression -> Typed.TypedTerm Syntax.PrimaryExpression
primaryExpressionArray x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "array"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the noArray variant of hydra.ext.csharp.syntax.PrimaryExpression
primaryExpressionNoArray :: Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression -> Typed.TypedTerm Syntax.PrimaryExpression
primaryExpressionNoArray x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "noArray"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.PrimaryExpression
primaryExpressionPrimaryExpression :: Typed.TypedName Syntax.PrimaryExpression
primaryExpressionPrimaryExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.PrimaryExpression")

-- | DSL injection for the anonymousMethod variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionAnonymousMethod :: Typed.TypedTerm Syntax.AnonymousMethodExpression -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionAnonymousMethod x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "anonymousMethod"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the anonymousObjectCreation variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionAnonymousObjectCreation :: Typed.TypedTerm (Maybe Syntax.MemberDeclaratorList) -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionAnonymousObjectCreation x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "anonymousObjectCreation"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the baseAccess variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionBaseAccess :: Typed.TypedTerm Syntax.BaseAccess -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionBaseAccess x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "baseAccess"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the checked variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionChecked :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionChecked x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "checked"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the defaultValue variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionDefaultValue :: Typed.TypedTerm Syntax.DefaultValueExpression -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionDefaultValue x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "defaultValue"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the delegateCreation variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionDelegateCreation :: Typed.TypedTerm Syntax.DelegateCreationExpression -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionDelegateCreation x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "delegateCreation"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the elementAccess variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionElementAccess :: Typed.TypedTerm Syntax.ElementAccess -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionElementAccess x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "elementAccess"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the interpolatedString variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionInterpolatedString :: Typed.TypedTerm Syntax.InterpolatedStringExpression -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionInterpolatedString x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "interpolatedString"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the invocation variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionInvocation :: Typed.TypedTerm Syntax.InvocationExpression -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionInvocation x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "invocation"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the literal variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionLiteral :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionLiteral x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "literal"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the memberAccess variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionMemberAccess :: Typed.TypedTerm Syntax.MemberAccess -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionMemberAccess x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "memberAccess"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the nameof variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionNameof :: Typed.TypedTerm Syntax.NamedEntity -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionNameof x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "nameof"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the nullConditionalElementAccess variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionNullConditionalElementAccess :: Typed.TypedTerm Syntax.NullConditionalElementAccess -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionNullConditionalElementAccess x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "nullConditionalElementAccess"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the nullConditionalMemberAccess variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionNullConditionalMemberAccess :: Typed.TypedTerm Syntax.NullConditionalMemberAccess -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionNullConditionalMemberAccess x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "nullConditionalMemberAccess"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the objectCreation variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionObjectCreation :: Typed.TypedTerm Syntax.ObjectCreationExpression -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionObjectCreation x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "objectCreation"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the parenthesized variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionParenthesized :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionParenthesized x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "parenthesized"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the pointerElementAccess variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionPointerElementAccess :: Typed.TypedTerm Syntax.PointerElementAccess -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionPointerElementAccess x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "pointerElementAccess"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the pointerMemberAccess variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionPointerMemberAccess :: Typed.TypedTerm Syntax.PointerMemberAccess -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionPointerMemberAccess x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "pointerMemberAccess"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the postDecrement variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionPostDecrement :: Typed.TypedTerm Syntax.PrimaryExpression -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionPostDecrement x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "postDecrement"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the postIncrement variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionPostIncrement :: Typed.TypedTerm Syntax.PrimaryExpression -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionPostIncrement x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "postIncrement"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionPrimaryNoArrayCreationExpression :: Typed.TypedName Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionPrimaryNoArrayCreationExpression =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression")

-- | DSL injection for the simpleName variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionSimpleName :: Typed.TypedTerm Syntax.SimpleName -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionSimpleName x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "simpleName"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the sizeof variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionSizeof :: Typed.TypedTerm Syntax.UnmanagedType -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionSizeof x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "sizeof"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the stackalloc variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionStackalloc :: Typed.TypedTerm Syntax.StackallocExpression -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionStackalloc x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "stackalloc"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the thisAccess variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionThisAccess :: Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionThisAccess =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "thisAccess"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the tuple variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionTuple :: Typed.TypedTerm Syntax.TupleExpression -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionTuple x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "tuple"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the typeof variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionTypeof :: Typed.TypedTerm Syntax.TypeofExpression -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionTypeof x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "typeof"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the unchecked variant of hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionUnchecked :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionUnchecked x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "unchecked"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the block variant of hydra.ext.csharp.syntax.PropertyBody
propertyBodyBlock :: Typed.TypedTerm Syntax.BlockPropertyBody -> Typed.TypedTerm Syntax.PropertyBody
propertyBodyBlock x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "block"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.PropertyBody
propertyBodyExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.PropertyBody
propertyBodyExpression x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "expression"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.PropertyBody
propertyBodyPropertyBody :: Typed.TypedName Syntax.PropertyBody
propertyBodyPropertyBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.PropertyBody")

-- | DSL name token for hydra.ext.csharp.syntax.PropertyDeclaration
propertyDeclarationPropertyDeclaration :: Typed.TypedName Syntax.PropertyDeclaration
propertyDeclarationPropertyDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.PropertyDeclaration")

-- | DSL injection for the refReturn variant of hydra.ext.csharp.syntax.PropertyDeclaration
propertyDeclarationRefReturn :: Typed.TypedTerm Syntax.RefReturnPropertyDeclaration -> Typed.TypedTerm Syntax.PropertyDeclaration
propertyDeclarationRefReturn x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "refReturn"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the standard variant of hydra.ext.csharp.syntax.PropertyDeclaration
propertyDeclarationStandard :: Typed.TypedTerm Syntax.StandardPropertyDeclaration -> Typed.TypedTerm Syntax.PropertyDeclaration
propertyDeclarationStandard x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "standard"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the abstract variant of hydra.ext.csharp.syntax.PropertyModifier
propertyModifierAbstract :: Typed.TypedTerm Syntax.PropertyModifier
propertyModifierAbstract =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "abstract"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the extern variant of hydra.ext.csharp.syntax.PropertyModifier
propertyModifierExtern :: Typed.TypedTerm Syntax.PropertyModifier
propertyModifierExtern =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "extern"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the internal variant of hydra.ext.csharp.syntax.PropertyModifier
propertyModifierInternal :: Typed.TypedTerm Syntax.PropertyModifier
propertyModifierInternal =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "internal"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the new variant of hydra.ext.csharp.syntax.PropertyModifier
propertyModifierNew :: Typed.TypedTerm Syntax.PropertyModifier
propertyModifierNew =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "new"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the override variant of hydra.ext.csharp.syntax.PropertyModifier
propertyModifierOverride :: Typed.TypedTerm Syntax.PropertyModifier
propertyModifierOverride =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "override"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the private variant of hydra.ext.csharp.syntax.PropertyModifier
propertyModifierPrivate :: Typed.TypedTerm Syntax.PropertyModifier
propertyModifierPrivate =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "private"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.csharp.syntax.PropertyModifier
propertyModifierPropertyModifier :: Typed.TypedName Syntax.PropertyModifier
propertyModifierPropertyModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.PropertyModifier")

-- | DSL injection for the protected variant of hydra.ext.csharp.syntax.PropertyModifier
propertyModifierProtected :: Typed.TypedTerm Syntax.PropertyModifier
propertyModifierProtected =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "protected"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the public variant of hydra.ext.csharp.syntax.PropertyModifier
propertyModifierPublic :: Typed.TypedTerm Syntax.PropertyModifier
propertyModifierPublic =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "public"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the sealed variant of hydra.ext.csharp.syntax.PropertyModifier
propertyModifierSealed :: Typed.TypedTerm Syntax.PropertyModifier
propertyModifierSealed =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "sealed"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the static variant of hydra.ext.csharp.syntax.PropertyModifier
propertyModifierStatic :: Typed.TypedTerm Syntax.PropertyModifier
propertyModifierStatic =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "static"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the unsafe variant of hydra.ext.csharp.syntax.PropertyModifier
propertyModifierUnsafe :: Typed.TypedTerm Syntax.PropertyModifier
propertyModifierUnsafe =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "unsafe"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the virtual variant of hydra.ext.csharp.syntax.PropertyModifier
propertyModifierVirtual :: Typed.TypedTerm Syntax.PropertyModifier
propertyModifierVirtual =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.PropertyModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "virtual"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL constructor for hydra.ext.csharp.syntax.QualifiedAliasMember
qualifiedAliasMember :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.QualifiedAliasMember
qualifiedAliasMember alias member arguments =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedAliasMember"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "alias"),
          Model.fieldTerm = (Typed.unTypedTerm alias)},
        Model.Field {
          Model.fieldName = (Model.Name "member"),
          Model.fieldTerm = (Typed.unTypedTerm member)},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Typed.unTypedTerm arguments)}]}))

-- | DSL accessor for the alias field of hydra.ext.csharp.syntax.QualifiedAliasMember
qualifiedAliasMemberAlias :: Typed.TypedTerm Syntax.QualifiedAliasMember -> Typed.TypedTerm Syntax.Identifier
qualifiedAliasMemberAlias x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedAliasMember"),
        Model.projectionFieldName = (Model.Name "alias")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the arguments field of hydra.ext.csharp.syntax.QualifiedAliasMember
qualifiedAliasMemberArguments :: Typed.TypedTerm Syntax.QualifiedAliasMember -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList)
qualifiedAliasMemberArguments x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedAliasMember"),
        Model.projectionFieldName = (Model.Name "arguments")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the member field of hydra.ext.csharp.syntax.QualifiedAliasMember
qualifiedAliasMemberMember :: Typed.TypedTerm Syntax.QualifiedAliasMember -> Typed.TypedTerm Syntax.Identifier
qualifiedAliasMemberMember x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedAliasMember"),
        Model.projectionFieldName = (Model.Name "member")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.QualifiedAliasMember
qualifiedAliasMemberQualifiedAliasMember :: Typed.TypedName Syntax.QualifiedAliasMember
qualifiedAliasMemberQualifiedAliasMember = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.QualifiedAliasMember")

-- | DSL updater for the alias field of hydra.ext.csharp.syntax.QualifiedAliasMember
qualifiedAliasMemberWithAlias :: Typed.TypedTerm Syntax.QualifiedAliasMember -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.QualifiedAliasMember
qualifiedAliasMemberWithAlias original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedAliasMember"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "alias"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "member"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedAliasMember"),
              Model.projectionFieldName = (Model.Name "member")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedAliasMember"),
              Model.projectionFieldName = (Model.Name "arguments")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the arguments field of hydra.ext.csharp.syntax.QualifiedAliasMember
qualifiedAliasMemberWithArguments :: Typed.TypedTerm Syntax.QualifiedAliasMember -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.QualifiedAliasMember
qualifiedAliasMemberWithArguments original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedAliasMember"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "alias"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedAliasMember"),
              Model.projectionFieldName = (Model.Name "alias")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "member"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedAliasMember"),
              Model.projectionFieldName = (Model.Name "member")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the member field of hydra.ext.csharp.syntax.QualifiedAliasMember
qualifiedAliasMemberWithMember :: Typed.TypedTerm Syntax.QualifiedAliasMember -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.QualifiedAliasMember
qualifiedAliasMemberWithMember original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedAliasMember"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "alias"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedAliasMember"),
              Model.projectionFieldName = (Model.Name "alias")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "member"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedAliasMember"),
              Model.projectionFieldName = (Model.Name "arguments")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for the hydra.ext.csharp.syntax.QualifiedIdentifier wrapper
qualifiedIdentifier :: Typed.TypedTerm [Syntax.Identifier] -> Typed.TypedTerm Syntax.QualifiedIdentifier
qualifiedIdentifier x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedIdentifier"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.QualifiedIdentifier
qualifiedIdentifierQualifiedIdentifier :: Typed.TypedName Syntax.QualifiedIdentifier
qualifiedIdentifierQualifiedIdentifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.QualifiedIdentifier")

-- | DSL constructor for hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName
qualifiedNamespaceOrTypeName :: Typed.TypedTerm Syntax.NamespaceOrTypeName -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.QualifiedNamespaceOrTypeName
qualifiedNamespaceOrTypeName namespaceOrType identifier arguments =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaceOrType"),
          Model.fieldTerm = (Typed.unTypedTerm namespaceOrType)},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm identifier)},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Typed.unTypedTerm arguments)}]}))

-- | DSL accessor for the arguments field of hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName
qualifiedNamespaceOrTypeNameArguments :: Typed.TypedTerm Syntax.QualifiedNamespaceOrTypeName -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList)
qualifiedNamespaceOrTypeNameArguments x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName"),
        Model.projectionFieldName = (Model.Name "arguments")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName
qualifiedNamespaceOrTypeNameIdentifier :: Typed.TypedTerm Syntax.QualifiedNamespaceOrTypeName -> Typed.TypedTerm Syntax.Identifier
qualifiedNamespaceOrTypeNameIdentifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName"),
        Model.projectionFieldName = (Model.Name "identifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the namespaceOrType field of hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName
qualifiedNamespaceOrTypeNameNamespaceOrType :: Typed.TypedTerm Syntax.QualifiedNamespaceOrTypeName -> Typed.TypedTerm Syntax.NamespaceOrTypeName
qualifiedNamespaceOrTypeNameNamespaceOrType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName"),
        Model.projectionFieldName = (Model.Name "namespaceOrType")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName
qualifiedNamespaceOrTypeNameQualifiedNamespaceOrTypeName :: Typed.TypedName Syntax.QualifiedNamespaceOrTypeName
qualifiedNamespaceOrTypeNameQualifiedNamespaceOrTypeName =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName")

-- | DSL updater for the arguments field of hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName
qualifiedNamespaceOrTypeNameWithArguments :: Typed.TypedTerm Syntax.QualifiedNamespaceOrTypeName -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.QualifiedNamespaceOrTypeName
qualifiedNamespaceOrTypeNameWithArguments original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaceOrType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName"),
              Model.projectionFieldName = (Model.Name "namespaceOrType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName
qualifiedNamespaceOrTypeNameWithIdentifier :: Typed.TypedTerm Syntax.QualifiedNamespaceOrTypeName -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.QualifiedNamespaceOrTypeName
qualifiedNamespaceOrTypeNameWithIdentifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaceOrType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName"),
              Model.projectionFieldName = (Model.Name "namespaceOrType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName"),
              Model.projectionFieldName = (Model.Name "arguments")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the namespaceOrType field of hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName
qualifiedNamespaceOrTypeNameWithNamespaceOrType :: Typed.TypedTerm Syntax.QualifiedNamespaceOrTypeName -> Typed.TypedTerm Syntax.NamespaceOrTypeName -> Typed.TypedTerm Syntax.QualifiedNamespaceOrTypeName
qualifiedNamespaceOrTypeNameWithNamespaceOrType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaceOrType"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "arguments"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QualifiedNamespaceOrTypeName"),
              Model.projectionFieldName = (Model.Name "arguments")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.QueryBody
queryBody :: Typed.TypedTerm [Syntax.QueryBodyClause] -> Typed.TypedTerm Syntax.SelectOrGroupClause -> Typed.TypedTerm (Maybe Syntax.QueryContinuation) -> Typed.TypedTerm Syntax.QueryBody
queryBody clauses selectOrGroup continuation =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBody"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "clauses"),
          Model.fieldTerm = (Typed.unTypedTerm clauses)},
        Model.Field {
          Model.fieldName = (Model.Name "selectOrGroup"),
          Model.fieldTerm = (Typed.unTypedTerm selectOrGroup)},
        Model.Field {
          Model.fieldName = (Model.Name "continuation"),
          Model.fieldTerm = (Typed.unTypedTerm continuation)}]}))

-- | DSL injection for the from variant of hydra.ext.csharp.syntax.QueryBodyClause
queryBodyClauseFrom :: Typed.TypedTerm Syntax.FromClause -> Typed.TypedTerm Syntax.QueryBodyClause
queryBodyClauseFrom x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBodyClause"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "from"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the join variant of hydra.ext.csharp.syntax.QueryBodyClause
queryBodyClauseJoin :: Typed.TypedTerm Syntax.JoinClause -> Typed.TypedTerm Syntax.QueryBodyClause
queryBodyClauseJoin x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBodyClause"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "join"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the let variant of hydra.ext.csharp.syntax.QueryBodyClause
queryBodyClauseLet :: Typed.TypedTerm Syntax.LetClause -> Typed.TypedTerm Syntax.QueryBodyClause
queryBodyClauseLet x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBodyClause"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "let"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the orderby variant of hydra.ext.csharp.syntax.QueryBodyClause
queryBodyClauseOrderby :: Typed.TypedTerm [Syntax.Ordering] -> Typed.TypedTerm Syntax.QueryBodyClause
queryBodyClauseOrderby x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBodyClause"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "orderby"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.QueryBodyClause
queryBodyClauseQueryBodyClause :: Typed.TypedName Syntax.QueryBodyClause
queryBodyClauseQueryBodyClause = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.QueryBodyClause")

-- | DSL injection for the where variant of hydra.ext.csharp.syntax.QueryBodyClause
queryBodyClauseWhere :: Typed.TypedTerm Syntax.BooleanExpression -> Typed.TypedTerm Syntax.QueryBodyClause
queryBodyClauseWhere x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBodyClause"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "where"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL accessor for the clauses field of hydra.ext.csharp.syntax.QueryBody
queryBodyClauses :: Typed.TypedTerm Syntax.QueryBody -> Typed.TypedTerm [Syntax.QueryBodyClause]
queryBodyClauses x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBody"),
        Model.projectionFieldName = (Model.Name "clauses")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the continuation field of hydra.ext.csharp.syntax.QueryBody
queryBodyContinuation :: Typed.TypedTerm Syntax.QueryBody -> Typed.TypedTerm (Maybe Syntax.QueryContinuation)
queryBodyContinuation x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBody"),
        Model.projectionFieldName = (Model.Name "continuation")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.QueryBody
queryBodyQueryBody :: Typed.TypedName Syntax.QueryBody
queryBodyQueryBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.QueryBody")

-- | DSL accessor for the selectOrGroup field of hydra.ext.csharp.syntax.QueryBody
queryBodySelectOrGroup :: Typed.TypedTerm Syntax.QueryBody -> Typed.TypedTerm Syntax.SelectOrGroupClause
queryBodySelectOrGroup x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBody"),
        Model.projectionFieldName = (Model.Name "selectOrGroup")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the clauses field of hydra.ext.csharp.syntax.QueryBody
queryBodyWithClauses :: Typed.TypedTerm Syntax.QueryBody -> Typed.TypedTerm [Syntax.QueryBodyClause] -> Typed.TypedTerm Syntax.QueryBody
queryBodyWithClauses original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBody"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "clauses"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "selectOrGroup"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBody"),
              Model.projectionFieldName = (Model.Name "selectOrGroup")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "continuation"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBody"),
              Model.projectionFieldName = (Model.Name "continuation")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the continuation field of hydra.ext.csharp.syntax.QueryBody
queryBodyWithContinuation :: Typed.TypedTerm Syntax.QueryBody -> Typed.TypedTerm (Maybe Syntax.QueryContinuation) -> Typed.TypedTerm Syntax.QueryBody
queryBodyWithContinuation original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBody"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "clauses"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBody"),
              Model.projectionFieldName = (Model.Name "clauses")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "selectOrGroup"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBody"),
              Model.projectionFieldName = (Model.Name "selectOrGroup")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "continuation"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the selectOrGroup field of hydra.ext.csharp.syntax.QueryBody
queryBodyWithSelectOrGroup :: Typed.TypedTerm Syntax.QueryBody -> Typed.TypedTerm Syntax.SelectOrGroupClause -> Typed.TypedTerm Syntax.QueryBody
queryBodyWithSelectOrGroup original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBody"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "clauses"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBody"),
              Model.projectionFieldName = (Model.Name "clauses")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "selectOrGroup"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "continuation"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryBody"),
              Model.projectionFieldName = (Model.Name "continuation")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.QueryContinuation
queryContinuation :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.QueryBody -> Typed.TypedTerm Syntax.QueryContinuation
queryContinuation into body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryContinuation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "into"),
          Model.fieldTerm = (Typed.unTypedTerm into)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.QueryContinuation
queryContinuationBody :: Typed.TypedTerm Syntax.QueryContinuation -> Typed.TypedTerm Syntax.QueryBody
queryContinuationBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryContinuation"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the into field of hydra.ext.csharp.syntax.QueryContinuation
queryContinuationInto :: Typed.TypedTerm Syntax.QueryContinuation -> Typed.TypedTerm Syntax.Identifier
queryContinuationInto x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryContinuation"),
        Model.projectionFieldName = (Model.Name "into")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.QueryContinuation
queryContinuationQueryContinuation :: Typed.TypedName Syntax.QueryContinuation
queryContinuationQueryContinuation = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.QueryContinuation")

-- | DSL updater for the body field of hydra.ext.csharp.syntax.QueryContinuation
queryContinuationWithBody :: Typed.TypedTerm Syntax.QueryContinuation -> Typed.TypedTerm Syntax.QueryBody -> Typed.TypedTerm Syntax.QueryContinuation
queryContinuationWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryContinuation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "into"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryContinuation"),
              Model.projectionFieldName = (Model.Name "into")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the into field of hydra.ext.csharp.syntax.QueryContinuation
queryContinuationWithInto :: Typed.TypedTerm Syntax.QueryContinuation -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.QueryContinuation
queryContinuationWithInto original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryContinuation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "into"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryContinuation"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.QueryExpression
queryExpression :: Typed.TypedTerm Syntax.FromClause -> Typed.TypedTerm Syntax.QueryBody -> Typed.TypedTerm Syntax.QueryExpression
queryExpression from body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "from"),
          Model.fieldTerm = (Typed.unTypedTerm from)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.QueryExpression
queryExpressionBody :: Typed.TypedTerm Syntax.QueryExpression -> Typed.TypedTerm Syntax.QueryBody
queryExpressionBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryExpression"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the from field of hydra.ext.csharp.syntax.QueryExpression
queryExpressionFrom :: Typed.TypedTerm Syntax.QueryExpression -> Typed.TypedTerm Syntax.FromClause
queryExpressionFrom x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryExpression"),
        Model.projectionFieldName = (Model.Name "from")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.QueryExpression
queryExpressionQueryExpression :: Typed.TypedName Syntax.QueryExpression
queryExpressionQueryExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.QueryExpression")

-- | DSL updater for the body field of hydra.ext.csharp.syntax.QueryExpression
queryExpressionWithBody :: Typed.TypedTerm Syntax.QueryExpression -> Typed.TypedTerm Syntax.QueryBody -> Typed.TypedTerm Syntax.QueryExpression
queryExpressionWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "from"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryExpression"),
              Model.projectionFieldName = (Model.Name "from")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the from field of hydra.ext.csharp.syntax.QueryExpression
queryExpressionWithFrom :: Typed.TypedTerm Syntax.QueryExpression -> Typed.TypedTerm Syntax.FromClause -> Typed.TypedTerm Syntax.QueryExpression
queryExpressionWithFrom original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "from"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.QueryExpression"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for the hydra.ext.csharp.syntax.RankSpecifier wrapper
rankSpecifier :: Typed.TypedTerm Int -> Typed.TypedTerm Syntax.RankSpecifier
rankSpecifier x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.RankSpecifier"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL constructor for hydra.ext.csharp.syntax.RankSpecifierArrayCreationExpression
rankSpecifierArrayCreationExpression :: Typed.TypedTerm Syntax.RankSpecifier -> Typed.TypedTerm Syntax.ArrayInitializer -> Typed.TypedTerm Syntax.RankSpecifierArrayCreationExpression
rankSpecifierArrayCreationExpression rankSpecifier initializer =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RankSpecifierArrayCreationExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "rankSpecifier"),
          Model.fieldTerm = (Typed.unTypedTerm rankSpecifier)},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Typed.unTypedTerm initializer)}]}))

-- | DSL accessor for the initializer field of hydra.ext.csharp.syntax.RankSpecifierArrayCreationExpression
rankSpecifierArrayCreationExpressionInitializer :: Typed.TypedTerm Syntax.RankSpecifierArrayCreationExpression -> Typed.TypedTerm Syntax.ArrayInitializer
rankSpecifierArrayCreationExpressionInitializer x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RankSpecifierArrayCreationExpression"),
        Model.projectionFieldName = (Model.Name "initializer")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the rankSpecifier field of hydra.ext.csharp.syntax.RankSpecifierArrayCreationExpression
rankSpecifierArrayCreationExpressionRankSpecifier :: Typed.TypedTerm Syntax.RankSpecifierArrayCreationExpression -> Typed.TypedTerm Syntax.RankSpecifier
rankSpecifierArrayCreationExpressionRankSpecifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RankSpecifierArrayCreationExpression"),
        Model.projectionFieldName = (Model.Name "rankSpecifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.RankSpecifierArrayCreationExpression
rankSpecifierArrayCreationExpressionRankSpecifierArrayCreationExpression :: Typed.TypedName Syntax.RankSpecifierArrayCreationExpression
rankSpecifierArrayCreationExpressionRankSpecifierArrayCreationExpression =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RankSpecifierArrayCreationExpression")

-- | DSL updater for the initializer field of hydra.ext.csharp.syntax.RankSpecifierArrayCreationExpression
rankSpecifierArrayCreationExpressionWithInitializer :: Typed.TypedTerm Syntax.RankSpecifierArrayCreationExpression -> Typed.TypedTerm Syntax.ArrayInitializer -> Typed.TypedTerm Syntax.RankSpecifierArrayCreationExpression
rankSpecifierArrayCreationExpressionWithInitializer original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RankSpecifierArrayCreationExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "rankSpecifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RankSpecifierArrayCreationExpression"),
              Model.projectionFieldName = (Model.Name "rankSpecifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the rankSpecifier field of hydra.ext.csharp.syntax.RankSpecifierArrayCreationExpression
rankSpecifierArrayCreationExpressionWithRankSpecifier :: Typed.TypedTerm Syntax.RankSpecifierArrayCreationExpression -> Typed.TypedTerm Syntax.RankSpecifier -> Typed.TypedTerm Syntax.RankSpecifierArrayCreationExpression
rankSpecifierArrayCreationExpressionWithRankSpecifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RankSpecifierArrayCreationExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "rankSpecifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RankSpecifierArrayCreationExpression"),
              Model.projectionFieldName = (Model.Name "initializer")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL name token for hydra.ext.csharp.syntax.RankSpecifier
rankSpecifierRankSpecifier :: Typed.TypedName Syntax.RankSpecifier
rankSpecifierRankSpecifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RankSpecifier")

-- | DSL injection for the block variant of hydra.ext.csharp.syntax.RefAccessorBody
refAccessorBodyBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.RefAccessorBody
refAccessorBodyBlock x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefAccessorBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "block"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the empty variant of hydra.ext.csharp.syntax.RefAccessorBody
refAccessorBodyEmpty :: Typed.TypedTerm Syntax.RefAccessorBody
refAccessorBodyEmpty =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefAccessorBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "empty"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.RefAccessorBody
refAccessorBodyRef :: Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.RefAccessorBody
refAccessorBodyRef x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefAccessorBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "ref"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.RefAccessorBody
refAccessorBodyRefAccessorBody :: Typed.TypedName Syntax.RefAccessorBody
refAccessorBodyRefAccessorBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefAccessorBody")

-- | DSL constructor for hydra.ext.csharp.syntax.RefConditionalExpression
refConditionalExpression :: Typed.TypedTerm Syntax.NullCoalescingExpression -> Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.RefConditionalExpression
refConditionalExpression condition true false =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefConditionalExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Typed.unTypedTerm condition)},
        Model.Field {
          Model.fieldName = (Model.Name "true"),
          Model.fieldTerm = (Typed.unTypedTerm true)},
        Model.Field {
          Model.fieldName = (Model.Name "false"),
          Model.fieldTerm = (Typed.unTypedTerm false)}]}))

-- | DSL accessor for the condition field of hydra.ext.csharp.syntax.RefConditionalExpression
refConditionalExpressionCondition :: Typed.TypedTerm Syntax.RefConditionalExpression -> Typed.TypedTerm Syntax.NullCoalescingExpression
refConditionalExpressionCondition x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefConditionalExpression"),
        Model.projectionFieldName = (Model.Name "condition")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the false field of hydra.ext.csharp.syntax.RefConditionalExpression
refConditionalExpressionFalse :: Typed.TypedTerm Syntax.RefConditionalExpression -> Typed.TypedTerm Syntax.VariableReference
refConditionalExpressionFalse x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefConditionalExpression"),
        Model.projectionFieldName = (Model.Name "false")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.RefConditionalExpression
refConditionalExpressionRefConditionalExpression :: Typed.TypedName Syntax.RefConditionalExpression
refConditionalExpressionRefConditionalExpression =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefConditionalExpression")

-- | DSL accessor for the true field of hydra.ext.csharp.syntax.RefConditionalExpression
refConditionalExpressionTrue :: Typed.TypedTerm Syntax.RefConditionalExpression -> Typed.TypedTerm Syntax.VariableReference
refConditionalExpressionTrue x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefConditionalExpression"),
        Model.projectionFieldName = (Model.Name "true")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the condition field of hydra.ext.csharp.syntax.RefConditionalExpression
refConditionalExpressionWithCondition :: Typed.TypedTerm Syntax.RefConditionalExpression -> Typed.TypedTerm Syntax.NullCoalescingExpression -> Typed.TypedTerm Syntax.RefConditionalExpression
refConditionalExpressionWithCondition original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefConditionalExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "true"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefConditionalExpression"),
              Model.projectionFieldName = (Model.Name "true")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "false"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefConditionalExpression"),
              Model.projectionFieldName = (Model.Name "false")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the false field of hydra.ext.csharp.syntax.RefConditionalExpression
refConditionalExpressionWithFalse :: Typed.TypedTerm Syntax.RefConditionalExpression -> Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.RefConditionalExpression
refConditionalExpressionWithFalse original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefConditionalExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefConditionalExpression"),
              Model.projectionFieldName = (Model.Name "condition")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "true"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefConditionalExpression"),
              Model.projectionFieldName = (Model.Name "true")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "false"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the true field of hydra.ext.csharp.syntax.RefConditionalExpression
refConditionalExpressionWithTrue :: Typed.TypedTerm Syntax.RefConditionalExpression -> Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.RefConditionalExpression
refConditionalExpressionWithTrue original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefConditionalExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefConditionalExpression"),
              Model.projectionFieldName = (Model.Name "condition")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "true"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "false"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefConditionalExpression"),
              Model.projectionFieldName = (Model.Name "false")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.RefGetAccessorDeclaration
refGetAccessorDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm (Maybe Syntax.AccessorModifier) -> Typed.TypedTerm Syntax.RefAccessorBody -> Typed.TypedTerm Syntax.RefGetAccessorDeclaration
refGetAccessorDeclaration attributes modifier body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefGetAccessorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "modifier"),
          Model.fieldTerm = (Typed.unTypedTerm modifier)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.RefGetAccessorDeclaration
refGetAccessorDeclarationAttributes :: Typed.TypedTerm Syntax.RefGetAccessorDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes)
refGetAccessorDeclarationAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefGetAccessorDeclaration"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.RefGetAccessorDeclaration
refGetAccessorDeclarationBody :: Typed.TypedTerm Syntax.RefGetAccessorDeclaration -> Typed.TypedTerm Syntax.RefAccessorBody
refGetAccessorDeclarationBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefGetAccessorDeclaration"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the modifier field of hydra.ext.csharp.syntax.RefGetAccessorDeclaration
refGetAccessorDeclarationModifier :: Typed.TypedTerm Syntax.RefGetAccessorDeclaration -> Typed.TypedTerm (Maybe Syntax.AccessorModifier)
refGetAccessorDeclarationModifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefGetAccessorDeclaration"),
        Model.projectionFieldName = (Model.Name "modifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.RefGetAccessorDeclaration
refGetAccessorDeclarationRefGetAccessorDeclaration :: Typed.TypedName Syntax.RefGetAccessorDeclaration
refGetAccessorDeclarationRefGetAccessorDeclaration =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefGetAccessorDeclaration")

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.RefGetAccessorDeclaration
refGetAccessorDeclarationWithAttributes :: Typed.TypedTerm Syntax.RefGetAccessorDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.RefGetAccessorDeclaration
refGetAccessorDeclarationWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefGetAccessorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "modifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefGetAccessorDeclaration"),
              Model.projectionFieldName = (Model.Name "modifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefGetAccessorDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the body field of hydra.ext.csharp.syntax.RefGetAccessorDeclaration
refGetAccessorDeclarationWithBody :: Typed.TypedTerm Syntax.RefGetAccessorDeclaration -> Typed.TypedTerm Syntax.RefAccessorBody -> Typed.TypedTerm Syntax.RefGetAccessorDeclaration
refGetAccessorDeclarationWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefGetAccessorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefGetAccessorDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefGetAccessorDeclaration"),
              Model.projectionFieldName = (Model.Name "modifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the modifier field of hydra.ext.csharp.syntax.RefGetAccessorDeclaration
refGetAccessorDeclarationWithModifier :: Typed.TypedTerm Syntax.RefGetAccessorDeclaration -> Typed.TypedTerm (Maybe Syntax.AccessorModifier) -> Typed.TypedTerm Syntax.RefGetAccessorDeclaration
refGetAccessorDeclarationWithModifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefGetAccessorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefGetAccessorDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefGetAccessorDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the block variant of hydra.ext.csharp.syntax.RefIndexerBody
refIndexerBodyBlock :: Typed.TypedTerm Syntax.RefGetAccessorDeclaration -> Typed.TypedTerm Syntax.RefIndexerBody
refIndexerBodyBlock x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "block"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.RefIndexerBody
refIndexerBodyRef :: Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.RefIndexerBody
refIndexerBodyRef x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "ref"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.RefIndexerBody
refIndexerBodyRefIndexerBody :: Typed.TypedName Syntax.RefIndexerBody
refIndexerBodyRefIndexerBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefIndexerBody")

-- | DSL constructor for hydra.ext.csharp.syntax.RefIndexerDeclaration
refIndexerDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.IndexerModifier] -> Typed.TypedTerm Syntax.RefKind -> Typed.TypedTerm Syntax.IndexerDeclarator -> Typed.TypedTerm Syntax.RefIndexerBody -> Typed.TypedTerm Syntax.RefIndexerDeclaration
refIndexerDeclaration attributes modifiers refKind declarator body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm modifiers)},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Typed.unTypedTerm refKind)},
        Model.Field {
          Model.fieldName = (Model.Name "declarator"),
          Model.fieldTerm = (Typed.unTypedTerm declarator)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.RefIndexerDeclaration
refIndexerDeclarationAttributes :: Typed.TypedTerm Syntax.RefIndexerDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes)
refIndexerDeclarationAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.RefIndexerDeclaration
refIndexerDeclarationBody :: Typed.TypedTerm Syntax.RefIndexerDeclaration -> Typed.TypedTerm Syntax.RefIndexerBody
refIndexerDeclarationBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the declarator field of hydra.ext.csharp.syntax.RefIndexerDeclaration
refIndexerDeclarationDeclarator :: Typed.TypedTerm Syntax.RefIndexerDeclaration -> Typed.TypedTerm Syntax.IndexerDeclarator
refIndexerDeclarationDeclarator x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"),
        Model.projectionFieldName = (Model.Name "declarator")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.RefIndexerDeclaration
refIndexerDeclarationModifiers :: Typed.TypedTerm Syntax.RefIndexerDeclaration -> Typed.TypedTerm [Syntax.IndexerModifier]
refIndexerDeclarationModifiers x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"),
        Model.projectionFieldName = (Model.Name "modifiers")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.RefIndexerDeclaration
refIndexerDeclarationRefIndexerDeclaration :: Typed.TypedName Syntax.RefIndexerDeclaration
refIndexerDeclarationRefIndexerDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration")

-- | DSL accessor for the refKind field of hydra.ext.csharp.syntax.RefIndexerDeclaration
refIndexerDeclarationRefKind :: Typed.TypedTerm Syntax.RefIndexerDeclaration -> Typed.TypedTerm Syntax.RefKind
refIndexerDeclarationRefKind x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"),
        Model.projectionFieldName = (Model.Name "refKind")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.RefIndexerDeclaration
refIndexerDeclarationWithAttributes :: Typed.TypedTerm Syntax.RefIndexerDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.RefIndexerDeclaration
refIndexerDeclarationWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "declarator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the body field of hydra.ext.csharp.syntax.RefIndexerDeclaration
refIndexerDeclarationWithBody :: Typed.TypedTerm Syntax.RefIndexerDeclaration -> Typed.TypedTerm Syntax.RefIndexerBody -> Typed.TypedTerm Syntax.RefIndexerDeclaration
refIndexerDeclarationWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "declarator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the declarator field of hydra.ext.csharp.syntax.RefIndexerDeclaration
refIndexerDeclarationWithDeclarator :: Typed.TypedTerm Syntax.RefIndexerDeclaration -> Typed.TypedTerm Syntax.IndexerDeclarator -> Typed.TypedTerm Syntax.RefIndexerDeclaration
refIndexerDeclarationWithDeclarator original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarator"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.RefIndexerDeclaration
refIndexerDeclarationWithModifiers :: Typed.TypedTerm Syntax.RefIndexerDeclaration -> Typed.TypedTerm [Syntax.IndexerModifier] -> Typed.TypedTerm Syntax.RefIndexerDeclaration
refIndexerDeclarationWithModifiers original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "declarator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the refKind field of hydra.ext.csharp.syntax.RefIndexerDeclaration
refIndexerDeclarationWithRefKind :: Typed.TypedTerm Syntax.RefIndexerDeclaration -> Typed.TypedTerm Syntax.RefKind -> Typed.TypedTerm Syntax.RefIndexerDeclaration
refIndexerDeclarationWithRefKind original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "declarator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "declarator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.RefKind
refKindRef :: Typed.TypedTerm Syntax.RefKind
refKindRef =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefKind"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "ref"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.csharp.syntax.RefKind
refKindRefKind :: Typed.TypedName Syntax.RefKind
refKindRefKind = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefKind")

-- | DSL injection for the refReadonly variant of hydra.ext.csharp.syntax.RefKind
refKindRefReadonly :: Typed.TypedTerm Syntax.RefKind
refKindRefReadonly =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefKind"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "refReadonly"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the block variant of hydra.ext.csharp.syntax.RefLocalFunctionBody
refLocalFunctionBodyBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.RefLocalFunctionBody
refLocalFunctionBodyBlock x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "block"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.RefLocalFunctionBody
refLocalFunctionBodyRef :: Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.RefLocalFunctionBody
refLocalFunctionBodyRef x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "ref"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.RefLocalFunctionBody
refLocalFunctionBodyRefLocalFunctionBody :: Typed.TypedName Syntax.RefLocalFunctionBody
refLocalFunctionBodyRefLocalFunctionBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionBody")

-- | DSL constructor for hydra.ext.csharp.syntax.RefLocalFunctionDeclaration
refLocalFunctionDeclaration :: Typed.TypedTerm [Syntax.RefLocalFunctionModifier] -> Typed.TypedTerm Syntax.RefKind -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.LocalFunctionHeader -> Typed.TypedTerm Syntax.RefLocalFunctionBody -> Typed.TypedTerm Syntax.RefLocalFunctionDeclaration
refLocalFunctionDeclaration modifiers refKind returnType header body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm modifiers)},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Typed.unTypedTerm refKind)},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Typed.unTypedTerm returnType)},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Typed.unTypedTerm header)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.RefLocalFunctionDeclaration
refLocalFunctionDeclarationBody :: Typed.TypedTerm Syntax.RefLocalFunctionDeclaration -> Typed.TypedTerm Syntax.RefLocalFunctionBody
refLocalFunctionDeclarationBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the header field of hydra.ext.csharp.syntax.RefLocalFunctionDeclaration
refLocalFunctionDeclarationHeader :: Typed.TypedTerm Syntax.RefLocalFunctionDeclaration -> Typed.TypedTerm Syntax.LocalFunctionHeader
refLocalFunctionDeclarationHeader x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"),
        Model.projectionFieldName = (Model.Name "header")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.RefLocalFunctionDeclaration
refLocalFunctionDeclarationModifiers :: Typed.TypedTerm Syntax.RefLocalFunctionDeclaration -> Typed.TypedTerm [Syntax.RefLocalFunctionModifier]
refLocalFunctionDeclarationModifiers x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"),
        Model.projectionFieldName = (Model.Name "modifiers")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the refKind field of hydra.ext.csharp.syntax.RefLocalFunctionDeclaration
refLocalFunctionDeclarationRefKind :: Typed.TypedTerm Syntax.RefLocalFunctionDeclaration -> Typed.TypedTerm Syntax.RefKind
refLocalFunctionDeclarationRefKind x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"),
        Model.projectionFieldName = (Model.Name "refKind")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.RefLocalFunctionDeclaration
refLocalFunctionDeclarationRefLocalFunctionDeclaration :: Typed.TypedName Syntax.RefLocalFunctionDeclaration
refLocalFunctionDeclarationRefLocalFunctionDeclaration =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration")

-- | DSL accessor for the returnType field of hydra.ext.csharp.syntax.RefLocalFunctionDeclaration
refLocalFunctionDeclarationReturnType :: Typed.TypedTerm Syntax.RefLocalFunctionDeclaration -> Typed.TypedTerm Syntax.Type
refLocalFunctionDeclarationReturnType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"),
        Model.projectionFieldName = (Model.Name "returnType")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the body field of hydra.ext.csharp.syntax.RefLocalFunctionDeclaration
refLocalFunctionDeclarationWithBody :: Typed.TypedTerm Syntax.RefLocalFunctionDeclaration -> Typed.TypedTerm Syntax.RefLocalFunctionBody -> Typed.TypedTerm Syntax.RefLocalFunctionDeclaration
refLocalFunctionDeclarationWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "header")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the header field of hydra.ext.csharp.syntax.RefLocalFunctionDeclaration
refLocalFunctionDeclarationWithHeader :: Typed.TypedTerm Syntax.RefLocalFunctionDeclaration -> Typed.TypedTerm Syntax.LocalFunctionHeader -> Typed.TypedTerm Syntax.RefLocalFunctionDeclaration
refLocalFunctionDeclarationWithHeader original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.RefLocalFunctionDeclaration
refLocalFunctionDeclarationWithModifiers :: Typed.TypedTerm Syntax.RefLocalFunctionDeclaration -> Typed.TypedTerm [Syntax.RefLocalFunctionModifier] -> Typed.TypedTerm Syntax.RefLocalFunctionDeclaration
refLocalFunctionDeclarationWithModifiers original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "header")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the refKind field of hydra.ext.csharp.syntax.RefLocalFunctionDeclaration
refLocalFunctionDeclarationWithRefKind :: Typed.TypedTerm Syntax.RefLocalFunctionDeclaration -> Typed.TypedTerm Syntax.RefKind -> Typed.TypedTerm Syntax.RefLocalFunctionDeclaration
refLocalFunctionDeclarationWithRefKind original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "header")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the returnType field of hydra.ext.csharp.syntax.RefLocalFunctionDeclaration
refLocalFunctionDeclarationWithReturnType :: Typed.TypedTerm Syntax.RefLocalFunctionDeclaration -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.RefLocalFunctionDeclaration
refLocalFunctionDeclarationWithReturnType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "header")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL name token for hydra.ext.csharp.syntax.RefLocalFunctionModifier
refLocalFunctionModifierRefLocalFunctionModifier :: Typed.TypedName Syntax.RefLocalFunctionModifier
refLocalFunctionModifierRefLocalFunctionModifier =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionModifier")

-- | DSL injection for the static variant of hydra.ext.csharp.syntax.RefLocalFunctionModifier
refLocalFunctionModifierStatic :: Typed.TypedTerm Syntax.RefLocalFunctionModifier
refLocalFunctionModifierStatic =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "static"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the unsafe variant of hydra.ext.csharp.syntax.RefLocalFunctionModifier
refLocalFunctionModifierUnsafe :: Typed.TypedTerm Syntax.RefLocalFunctionModifier
refLocalFunctionModifierUnsafe =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalFunctionModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "unsafe"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL constructor for hydra.ext.csharp.syntax.RefLocalVariableDeclaration
refLocalVariableDeclaration :: Typed.TypedTerm Syntax.RefKind -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm [Syntax.RefLocalVariableDeclarator] -> Typed.TypedTerm Syntax.RefLocalVariableDeclaration
refLocalVariableDeclaration refKind type_ declarators =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Typed.unTypedTerm refKind)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Typed.unTypedTerm declarators)}]}))

-- | DSL accessor for the declarators field of hydra.ext.csharp.syntax.RefLocalVariableDeclaration
refLocalVariableDeclarationDeclarators :: Typed.TypedTerm Syntax.RefLocalVariableDeclaration -> Typed.TypedTerm [Syntax.RefLocalVariableDeclarator]
refLocalVariableDeclarationDeclarators x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclaration"),
        Model.projectionFieldName = (Model.Name "declarators")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the refKind field of hydra.ext.csharp.syntax.RefLocalVariableDeclaration
refLocalVariableDeclarationRefKind :: Typed.TypedTerm Syntax.RefLocalVariableDeclaration -> Typed.TypedTerm Syntax.RefKind
refLocalVariableDeclarationRefKind x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclaration"),
        Model.projectionFieldName = (Model.Name "refKind")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.RefLocalVariableDeclaration
refLocalVariableDeclarationRefLocalVariableDeclaration :: Typed.TypedName Syntax.RefLocalVariableDeclaration
refLocalVariableDeclarationRefLocalVariableDeclaration =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclaration")

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.RefLocalVariableDeclaration
refLocalVariableDeclarationType :: Typed.TypedTerm Syntax.RefLocalVariableDeclaration -> Typed.TypedTerm Syntax.Type
refLocalVariableDeclarationType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclaration"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the declarators field of hydra.ext.csharp.syntax.RefLocalVariableDeclaration
refLocalVariableDeclarationWithDeclarators :: Typed.TypedTerm Syntax.RefLocalVariableDeclaration -> Typed.TypedTerm [Syntax.RefLocalVariableDeclarator] -> Typed.TypedTerm Syntax.RefLocalVariableDeclaration
refLocalVariableDeclarationWithDeclarators original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the refKind field of hydra.ext.csharp.syntax.RefLocalVariableDeclaration
refLocalVariableDeclarationWithRefKind :: Typed.TypedTerm Syntax.RefLocalVariableDeclaration -> Typed.TypedTerm Syntax.RefKind -> Typed.TypedTerm Syntax.RefLocalVariableDeclaration
refLocalVariableDeclarationWithRefKind original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclaration"),
              Model.projectionFieldName = (Model.Name "declarators")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.RefLocalVariableDeclaration
refLocalVariableDeclarationWithType :: Typed.TypedTerm Syntax.RefLocalVariableDeclaration -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.RefLocalVariableDeclaration
refLocalVariableDeclarationWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclaration"),
              Model.projectionFieldName = (Model.Name "declarators")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.RefLocalVariableDeclarator
refLocalVariableDeclarator :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.RefLocalVariableDeclarator
refLocalVariableDeclarator left right =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm left)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm right)}]}))

-- | DSL accessor for the left field of hydra.ext.csharp.syntax.RefLocalVariableDeclarator
refLocalVariableDeclaratorLeft :: Typed.TypedTerm Syntax.RefLocalVariableDeclarator -> Typed.TypedTerm Syntax.Identifier
refLocalVariableDeclaratorLeft x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclarator"),
        Model.projectionFieldName = (Model.Name "left")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.RefLocalVariableDeclarator
refLocalVariableDeclaratorRefLocalVariableDeclarator :: Typed.TypedName Syntax.RefLocalVariableDeclarator
refLocalVariableDeclaratorRefLocalVariableDeclarator =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclarator")

-- | DSL accessor for the right field of hydra.ext.csharp.syntax.RefLocalVariableDeclarator
refLocalVariableDeclaratorRight :: Typed.TypedTerm Syntax.RefLocalVariableDeclarator -> Typed.TypedTerm Syntax.VariableReference
refLocalVariableDeclaratorRight x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclarator"),
        Model.projectionFieldName = (Model.Name "right")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the left field of hydra.ext.csharp.syntax.RefLocalVariableDeclarator
refLocalVariableDeclaratorWithLeft :: Typed.TypedTerm Syntax.RefLocalVariableDeclarator -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.RefLocalVariableDeclarator
refLocalVariableDeclaratorWithLeft original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclarator"),
              Model.projectionFieldName = (Model.Name "right")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the right field of hydra.ext.csharp.syntax.RefLocalVariableDeclarator
refLocalVariableDeclaratorWithRight :: Typed.TypedTerm Syntax.RefLocalVariableDeclarator -> Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.RefLocalVariableDeclarator
refLocalVariableDeclaratorWithRight original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "left"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefLocalVariableDeclarator"),
              Model.projectionFieldName = (Model.Name "left")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "right"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the block variant of hydra.ext.csharp.syntax.RefMethodBody
refMethodBodyBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.RefMethodBody
refMethodBodyBlock x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefMethodBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "block"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the empty variant of hydra.ext.csharp.syntax.RefMethodBody
refMethodBodyEmpty :: Typed.TypedTerm Syntax.RefMethodBody
refMethodBodyEmpty =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefMethodBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "empty"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.RefMethodBody
refMethodBodyRef :: Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.RefMethodBody
refMethodBodyRef x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefMethodBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "ref"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.RefMethodBody
refMethodBodyRefMethodBody :: Typed.TypedName Syntax.RefMethodBody
refMethodBodyRefMethodBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefMethodBody")

-- | DSL injection for the abstract variant of hydra.ext.csharp.syntax.RefMethodModifier
refMethodModifierAbstract :: Typed.TypedTerm Syntax.RefMethodModifier
refMethodModifierAbstract =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefMethodModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "abstract"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the extern variant of hydra.ext.csharp.syntax.RefMethodModifier
refMethodModifierExtern :: Typed.TypedTerm Syntax.RefMethodModifier
refMethodModifierExtern =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefMethodModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "extern"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the internal variant of hydra.ext.csharp.syntax.RefMethodModifier
refMethodModifierInternal :: Typed.TypedTerm Syntax.RefMethodModifier
refMethodModifierInternal =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefMethodModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "internal"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the new variant of hydra.ext.csharp.syntax.RefMethodModifier
refMethodModifierNew :: Typed.TypedTerm Syntax.RefMethodModifier
refMethodModifierNew =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefMethodModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "new"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the override variant of hydra.ext.csharp.syntax.RefMethodModifier
refMethodModifierOverride :: Typed.TypedTerm Syntax.RefMethodModifier
refMethodModifierOverride =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefMethodModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "override"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the private variant of hydra.ext.csharp.syntax.RefMethodModifier
refMethodModifierPrivate :: Typed.TypedTerm Syntax.RefMethodModifier
refMethodModifierPrivate =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefMethodModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "private"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the protected variant of hydra.ext.csharp.syntax.RefMethodModifier
refMethodModifierProtected :: Typed.TypedTerm Syntax.RefMethodModifier
refMethodModifierProtected =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefMethodModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "protected"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the public variant of hydra.ext.csharp.syntax.RefMethodModifier
refMethodModifierPublic :: Typed.TypedTerm Syntax.RefMethodModifier
refMethodModifierPublic =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefMethodModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "public"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.csharp.syntax.RefMethodModifier
refMethodModifierRefMethodModifier :: Typed.TypedName Syntax.RefMethodModifier
refMethodModifierRefMethodModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefMethodModifier")

-- | DSL injection for the sealed variant of hydra.ext.csharp.syntax.RefMethodModifier
refMethodModifierSealed :: Typed.TypedTerm Syntax.RefMethodModifier
refMethodModifierSealed =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefMethodModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "sealed"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the static variant of hydra.ext.csharp.syntax.RefMethodModifier
refMethodModifierStatic :: Typed.TypedTerm Syntax.RefMethodModifier
refMethodModifierStatic =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefMethodModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "static"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the unsafe variant of hydra.ext.csharp.syntax.RefMethodModifier
refMethodModifierUnsafe :: Typed.TypedTerm Syntax.RefMethodModifier
refMethodModifierUnsafe =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefMethodModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "unsafe"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the virtual variant of hydra.ext.csharp.syntax.RefMethodModifier
refMethodModifierVirtual :: Typed.TypedTerm Syntax.RefMethodModifier
refMethodModifierVirtual =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefMethodModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "virtual"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the block variant of hydra.ext.csharp.syntax.RefPropertyBody
refPropertyBodyBlock :: Typed.TypedTerm Syntax.RefGetAccessorDeclaration -> Typed.TypedTerm Syntax.RefPropertyBody
refPropertyBodyBlock x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefPropertyBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "block"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.RefPropertyBody
refPropertyBodyRef :: Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.RefPropertyBody
refPropertyBodyRef x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefPropertyBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "ref"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.RefPropertyBody
refPropertyBodyRefPropertyBody :: Typed.TypedName Syntax.RefPropertyBody
refPropertyBodyRefPropertyBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefPropertyBody")

-- | DSL constructor for hydra.ext.csharp.syntax.RefReturnMethodDeclaration
refReturnMethodDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.RefMethodModifier] -> Typed.TypedTerm Syntax.RefKind -> Typed.TypedTerm Syntax.ReturnType -> Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm Syntax.RefMethodBody -> Typed.TypedTerm Syntax.RefReturnMethodDeclaration
refReturnMethodDeclaration attributes modifiers kind returnType header body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm modifiers)},
        Model.Field {
          Model.fieldName = (Model.Name "kind"),
          Model.fieldTerm = (Typed.unTypedTerm kind)},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Typed.unTypedTerm returnType)},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Typed.unTypedTerm header)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.RefReturnMethodDeclaration
refReturnMethodDeclarationAttributes :: Typed.TypedTerm Syntax.RefReturnMethodDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes)
refReturnMethodDeclarationAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.RefReturnMethodDeclaration
refReturnMethodDeclarationBody :: Typed.TypedTerm Syntax.RefReturnMethodDeclaration -> Typed.TypedTerm Syntax.RefMethodBody
refReturnMethodDeclarationBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the header field of hydra.ext.csharp.syntax.RefReturnMethodDeclaration
refReturnMethodDeclarationHeader :: Typed.TypedTerm Syntax.RefReturnMethodDeclaration -> Typed.TypedTerm Syntax.MethodHeader
refReturnMethodDeclarationHeader x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
        Model.projectionFieldName = (Model.Name "header")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the kind field of hydra.ext.csharp.syntax.RefReturnMethodDeclaration
refReturnMethodDeclarationKind :: Typed.TypedTerm Syntax.RefReturnMethodDeclaration -> Typed.TypedTerm Syntax.RefKind
refReturnMethodDeclarationKind x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
        Model.projectionFieldName = (Model.Name "kind")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.RefReturnMethodDeclaration
refReturnMethodDeclarationModifiers :: Typed.TypedTerm Syntax.RefReturnMethodDeclaration -> Typed.TypedTerm [Syntax.RefMethodModifier]
refReturnMethodDeclarationModifiers x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
        Model.projectionFieldName = (Model.Name "modifiers")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.RefReturnMethodDeclaration
refReturnMethodDeclarationRefReturnMethodDeclaration :: Typed.TypedName Syntax.RefReturnMethodDeclaration
refReturnMethodDeclarationRefReturnMethodDeclaration =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration")

-- | DSL accessor for the returnType field of hydra.ext.csharp.syntax.RefReturnMethodDeclaration
refReturnMethodDeclarationReturnType :: Typed.TypedTerm Syntax.RefReturnMethodDeclaration -> Typed.TypedTerm Syntax.ReturnType
refReturnMethodDeclarationReturnType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
        Model.projectionFieldName = (Model.Name "returnType")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.RefReturnMethodDeclaration
refReturnMethodDeclarationWithAttributes :: Typed.TypedTerm Syntax.RefReturnMethodDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.RefReturnMethodDeclaration
refReturnMethodDeclarationWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "kind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "kind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "header")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the body field of hydra.ext.csharp.syntax.RefReturnMethodDeclaration
refReturnMethodDeclarationWithBody :: Typed.TypedTerm Syntax.RefReturnMethodDeclaration -> Typed.TypedTerm Syntax.RefMethodBody -> Typed.TypedTerm Syntax.RefReturnMethodDeclaration
refReturnMethodDeclarationWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "kind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "kind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "header")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the header field of hydra.ext.csharp.syntax.RefReturnMethodDeclaration
refReturnMethodDeclarationWithHeader :: Typed.TypedTerm Syntax.RefReturnMethodDeclaration -> Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm Syntax.RefReturnMethodDeclaration
refReturnMethodDeclarationWithHeader original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "kind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "kind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the kind field of hydra.ext.csharp.syntax.RefReturnMethodDeclaration
refReturnMethodDeclarationWithKind :: Typed.TypedTerm Syntax.RefReturnMethodDeclaration -> Typed.TypedTerm Syntax.RefKind -> Typed.TypedTerm Syntax.RefReturnMethodDeclaration
refReturnMethodDeclarationWithKind original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "kind"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "header")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.RefReturnMethodDeclaration
refReturnMethodDeclarationWithModifiers :: Typed.TypedTerm Syntax.RefReturnMethodDeclaration -> Typed.TypedTerm [Syntax.RefMethodModifier] -> Typed.TypedTerm Syntax.RefReturnMethodDeclaration
refReturnMethodDeclarationWithModifiers original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "kind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "kind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "header")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the returnType field of hydra.ext.csharp.syntax.RefReturnMethodDeclaration
refReturnMethodDeclarationWithReturnType :: Typed.TypedTerm Syntax.RefReturnMethodDeclaration -> Typed.TypedTerm Syntax.ReturnType -> Typed.TypedTerm Syntax.RefReturnMethodDeclaration
refReturnMethodDeclarationWithReturnType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "kind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "kind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "header")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.RefReturnPropertyDeclaration
refReturnPropertyDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.PropertyModifier] -> Typed.TypedTerm Syntax.RefKind -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.MemberName -> Typed.TypedTerm Syntax.RefPropertyBody -> Typed.TypedTerm Syntax.RefReturnPropertyDeclaration
refReturnPropertyDeclaration attributes modifiers refKind type_ name body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm modifiers)},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Typed.unTypedTerm refKind)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.RefReturnPropertyDeclaration
refReturnPropertyDeclarationAttributes :: Typed.TypedTerm Syntax.RefReturnPropertyDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes)
refReturnPropertyDeclarationAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.RefReturnPropertyDeclaration
refReturnPropertyDeclarationBody :: Typed.TypedTerm Syntax.RefReturnPropertyDeclaration -> Typed.TypedTerm Syntax.RefPropertyBody
refReturnPropertyDeclarationBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.RefReturnPropertyDeclaration
refReturnPropertyDeclarationModifiers :: Typed.TypedTerm Syntax.RefReturnPropertyDeclaration -> Typed.TypedTerm [Syntax.PropertyModifier]
refReturnPropertyDeclarationModifiers x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
        Model.projectionFieldName = (Model.Name "modifiers")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the name field of hydra.ext.csharp.syntax.RefReturnPropertyDeclaration
refReturnPropertyDeclarationName :: Typed.TypedTerm Syntax.RefReturnPropertyDeclaration -> Typed.TypedTerm Syntax.MemberName
refReturnPropertyDeclarationName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the refKind field of hydra.ext.csharp.syntax.RefReturnPropertyDeclaration
refReturnPropertyDeclarationRefKind :: Typed.TypedTerm Syntax.RefReturnPropertyDeclaration -> Typed.TypedTerm Syntax.RefKind
refReturnPropertyDeclarationRefKind x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
        Model.projectionFieldName = (Model.Name "refKind")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.RefReturnPropertyDeclaration
refReturnPropertyDeclarationRefReturnPropertyDeclaration :: Typed.TypedName Syntax.RefReturnPropertyDeclaration
refReturnPropertyDeclarationRefReturnPropertyDeclaration =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration")

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.RefReturnPropertyDeclaration
refReturnPropertyDeclarationType :: Typed.TypedTerm Syntax.RefReturnPropertyDeclaration -> Typed.TypedTerm Syntax.Type
refReturnPropertyDeclarationType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.RefReturnPropertyDeclaration
refReturnPropertyDeclarationWithAttributes :: Typed.TypedTerm Syntax.RefReturnPropertyDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.RefReturnPropertyDeclaration
refReturnPropertyDeclarationWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the body field of hydra.ext.csharp.syntax.RefReturnPropertyDeclaration
refReturnPropertyDeclarationWithBody :: Typed.TypedTerm Syntax.RefReturnPropertyDeclaration -> Typed.TypedTerm Syntax.RefPropertyBody -> Typed.TypedTerm Syntax.RefReturnPropertyDeclaration
refReturnPropertyDeclarationWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.RefReturnPropertyDeclaration
refReturnPropertyDeclarationWithModifiers :: Typed.TypedTerm Syntax.RefReturnPropertyDeclaration -> Typed.TypedTerm [Syntax.PropertyModifier] -> Typed.TypedTerm Syntax.RefReturnPropertyDeclaration
refReturnPropertyDeclarationWithModifiers original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.csharp.syntax.RefReturnPropertyDeclaration
refReturnPropertyDeclarationWithName :: Typed.TypedTerm Syntax.RefReturnPropertyDeclaration -> Typed.TypedTerm Syntax.MemberName -> Typed.TypedTerm Syntax.RefReturnPropertyDeclaration
refReturnPropertyDeclarationWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the refKind field of hydra.ext.csharp.syntax.RefReturnPropertyDeclaration
refReturnPropertyDeclarationWithRefKind :: Typed.TypedTerm Syntax.RefReturnPropertyDeclaration -> Typed.TypedTerm Syntax.RefKind -> Typed.TypedTerm Syntax.RefReturnPropertyDeclaration
refReturnPropertyDeclarationWithRefKind original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.RefReturnPropertyDeclaration
refReturnPropertyDeclarationWithType :: Typed.TypedTerm Syntax.RefReturnPropertyDeclaration -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.RefReturnPropertyDeclaration
refReturnPropertyDeclarationWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefReturnPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration
refVarImplicitlyTypedLocalVariableDeclaration :: Typed.TypedTerm Syntax.RefKind -> Typed.TypedTerm Syntax.RefLocalVariableDeclarator -> Typed.TypedTerm Syntax.RefVarImplicitlyTypedLocalVariableDeclaration
refVarImplicitlyTypedLocalVariableDeclaration refKind declarator =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Typed.unTypedTerm refKind)},
        Model.Field {
          Model.fieldName = (Model.Name "declarator"),
          Model.fieldTerm = (Typed.unTypedTerm declarator)}]}))

-- | DSL accessor for the declarator field of hydra.ext.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration
refVarImplicitlyTypedLocalVariableDeclarationDeclarator :: Typed.TypedTerm Syntax.RefVarImplicitlyTypedLocalVariableDeclaration -> Typed.TypedTerm Syntax.RefLocalVariableDeclarator
refVarImplicitlyTypedLocalVariableDeclarationDeclarator x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration"),
        Model.projectionFieldName = (Model.Name "declarator")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the refKind field of hydra.ext.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration
refVarImplicitlyTypedLocalVariableDeclarationRefKind :: Typed.TypedTerm Syntax.RefVarImplicitlyTypedLocalVariableDeclaration -> Typed.TypedTerm Syntax.RefKind
refVarImplicitlyTypedLocalVariableDeclarationRefKind x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration"),
        Model.projectionFieldName = (Model.Name "refKind")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration
refVarImplicitlyTypedLocalVariableDeclarationRefVarImplicitlyTypedLocalVariableDeclaration :: Typed.TypedName Syntax.RefVarImplicitlyTypedLocalVariableDeclaration
refVarImplicitlyTypedLocalVariableDeclarationRefVarImplicitlyTypedLocalVariableDeclaration =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration")

-- | DSL updater for the declarator field of hydra.ext.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration
refVarImplicitlyTypedLocalVariableDeclarationWithDeclarator :: Typed.TypedTerm Syntax.RefVarImplicitlyTypedLocalVariableDeclaration -> Typed.TypedTerm Syntax.RefLocalVariableDeclarator -> Typed.TypedTerm Syntax.RefVarImplicitlyTypedLocalVariableDeclaration
refVarImplicitlyTypedLocalVariableDeclarationWithDeclarator original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration"),
              Model.projectionFieldName = (Model.Name "refKind")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarator"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the refKind field of hydra.ext.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration
refVarImplicitlyTypedLocalVariableDeclarationWithRefKind :: Typed.TypedTerm Syntax.RefVarImplicitlyTypedLocalVariableDeclaration -> Typed.TypedTerm Syntax.RefKind -> Typed.TypedTerm Syntax.RefVarImplicitlyTypedLocalVariableDeclaration
refVarImplicitlyTypedLocalVariableDeclarationWithRefKind original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "refKind"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "declarator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration"),
              Model.projectionFieldName = (Model.Name "declarator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the array variant of hydra.ext.csharp.syntax.ReferenceType
referenceTypeArray :: Typed.TypedTerm Syntax.ArrayType -> Typed.TypedTerm Syntax.ReferenceType
referenceTypeArray x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ReferenceType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "array"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the class variant of hydra.ext.csharp.syntax.ReferenceType
referenceTypeClass :: Typed.TypedTerm Syntax.ClassType -> Typed.TypedTerm Syntax.ReferenceType
referenceTypeClass x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ReferenceType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "class"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the delegate variant of hydra.ext.csharp.syntax.ReferenceType
referenceTypeDelegate :: Typed.TypedTerm Syntax.DelegateType -> Typed.TypedTerm Syntax.ReferenceType
referenceTypeDelegate x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ReferenceType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "delegate"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the dynamic variant of hydra.ext.csharp.syntax.ReferenceType
referenceTypeDynamic :: Typed.TypedTerm Syntax.ReferenceType
referenceTypeDynamic =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ReferenceType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "dynamic"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the interface variant of hydra.ext.csharp.syntax.ReferenceType
referenceTypeInterface :: Typed.TypedTerm Syntax.InterfaceType -> Typed.TypedTerm Syntax.ReferenceType
referenceTypeInterface x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ReferenceType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "interface"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.ReferenceType
referenceTypeReferenceType :: Typed.TypedName Syntax.ReferenceType
referenceTypeReferenceType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ReferenceType")

-- | DSL constructor for hydra.ext.csharp.syntax.RegularInterpolation
regularInterpolation :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.RegularInterpolation
regularInterpolation expression width format =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RegularInterpolation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm expression)},
        Model.Field {
          Model.fieldName = (Model.Name "width"),
          Model.fieldTerm = (Typed.unTypedTerm width)},
        Model.Field {
          Model.fieldName = (Model.Name "format"),
          Model.fieldTerm = (Typed.unTypedTerm format)}]}))

-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.RegularInterpolation
regularInterpolationExpression :: Typed.TypedTerm Syntax.RegularInterpolation -> Typed.TypedTerm Syntax.Expression
regularInterpolationExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RegularInterpolation"),
        Model.projectionFieldName = (Model.Name "expression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the format field of hydra.ext.csharp.syntax.RegularInterpolation
regularInterpolationFormat :: Typed.TypedTerm Syntax.RegularInterpolation -> Typed.TypedTerm (Maybe String)
regularInterpolationFormat x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RegularInterpolation"),
        Model.projectionFieldName = (Model.Name "format")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.RegularInterpolation
regularInterpolationRegularInterpolation :: Typed.TypedName Syntax.RegularInterpolation
regularInterpolationRegularInterpolation = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RegularInterpolation")

-- | DSL accessor for the width field of hydra.ext.csharp.syntax.RegularInterpolation
regularInterpolationWidth :: Typed.TypedTerm Syntax.RegularInterpolation -> Typed.TypedTerm (Maybe Syntax.Expression)
regularInterpolationWidth x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RegularInterpolation"),
        Model.projectionFieldName = (Model.Name "width")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the expression field of hydra.ext.csharp.syntax.RegularInterpolation
regularInterpolationWithExpression :: Typed.TypedTerm Syntax.RegularInterpolation -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.RegularInterpolation
regularInterpolationWithExpression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RegularInterpolation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "width"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RegularInterpolation"),
              Model.projectionFieldName = (Model.Name "width")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "format"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RegularInterpolation"),
              Model.projectionFieldName = (Model.Name "format")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the format field of hydra.ext.csharp.syntax.RegularInterpolation
regularInterpolationWithFormat :: Typed.TypedTerm Syntax.RegularInterpolation -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.RegularInterpolation
regularInterpolationWithFormat original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RegularInterpolation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RegularInterpolation"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "width"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RegularInterpolation"),
              Model.projectionFieldName = (Model.Name "width")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "format"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the width field of hydra.ext.csharp.syntax.RegularInterpolation
regularInterpolationWithWidth :: Typed.TypedTerm Syntax.RegularInterpolation -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.RegularInterpolation
regularInterpolationWithWidth original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.RegularInterpolation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RegularInterpolation"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "width"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "format"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RegularInterpolation"),
              Model.projectionFieldName = (Model.Name "format")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the asType variant of hydra.ext.csharp.syntax.RelationalExpression
relationalExpressionAsType :: Typed.TypedTerm Syntax.AsTypeExpression -> Typed.TypedTerm Syntax.RelationalExpression
relationalExpressionAsType x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RelationalExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "asType"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the binary variant of hydra.ext.csharp.syntax.RelationalExpression
relationalExpressionBinary :: Typed.TypedTerm Syntax.BinaryRelationalExpression -> Typed.TypedTerm Syntax.RelationalExpression
relationalExpressionBinary x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RelationalExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "binary"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the isPattern variant of hydra.ext.csharp.syntax.RelationalExpression
relationalExpressionIsPattern :: Typed.TypedTerm Syntax.IsPatternExpression -> Typed.TypedTerm Syntax.RelationalExpression
relationalExpressionIsPattern x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RelationalExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "isPattern"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the isType variant of hydra.ext.csharp.syntax.RelationalExpression
relationalExpressionIsType :: Typed.TypedTerm Syntax.IsTypeExpression -> Typed.TypedTerm Syntax.RelationalExpression
relationalExpressionIsType x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RelationalExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "isType"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.RelationalExpression
relationalExpressionRelationalExpression :: Typed.TypedName Syntax.RelationalExpression
relationalExpressionRelationalExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RelationalExpression")

-- | DSL injection for the simple variant of hydra.ext.csharp.syntax.RelationalExpression
relationalExpressionSimple :: Typed.TypedTerm Syntax.ShiftExpression -> Typed.TypedTerm Syntax.RelationalExpression
relationalExpressionSimple x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RelationalExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "simple"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the greaterThan variant of hydra.ext.csharp.syntax.RelationalOperator
relationalOperatorGreaterThan :: Typed.TypedTerm Syntax.RelationalOperator
relationalOperatorGreaterThan =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RelationalOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "greaterThan"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the greaterThanOrEqual variant of hydra.ext.csharp.syntax.RelationalOperator
relationalOperatorGreaterThanOrEqual :: Typed.TypedTerm Syntax.RelationalOperator
relationalOperatorGreaterThanOrEqual =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RelationalOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "greaterThanOrEqual"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the lessThan variant of hydra.ext.csharp.syntax.RelationalOperator
relationalOperatorLessThan :: Typed.TypedTerm Syntax.RelationalOperator
relationalOperatorLessThan =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RelationalOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "lessThan"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the lessThanOrEqual variant of hydra.ext.csharp.syntax.RelationalOperator
relationalOperatorLessThanOrEqual :: Typed.TypedTerm Syntax.RelationalOperator
relationalOperatorLessThanOrEqual =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.RelationalOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "lessThanOrEqual"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.csharp.syntax.RelationalOperator
relationalOperatorRelationalOperator :: Typed.TypedName Syntax.RelationalOperator
relationalOperatorRelationalOperator = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.RelationalOperator")

-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.ResourceAcquisition
resourceAcquisitionExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ResourceAcquisition
resourceAcquisitionExpression x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ResourceAcquisition"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "expression"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the local variant of hydra.ext.csharp.syntax.ResourceAcquisition
resourceAcquisitionLocal :: Typed.TypedTerm Syntax.LocalVariableDeclaration -> Typed.TypedTerm Syntax.ResourceAcquisition
resourceAcquisitionLocal x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ResourceAcquisition"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "local"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.ResourceAcquisition
resourceAcquisitionResourceAcquisition :: Typed.TypedName Syntax.ResourceAcquisition
resourceAcquisitionResourceAcquisition = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ResourceAcquisition")

-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.ReturnStatement
returnStatementRef :: Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.ReturnStatement
returnStatementRef x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ReturnStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "ref"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.ReturnStatement
returnStatementReturnStatement :: Typed.TypedName Syntax.ReturnStatement
returnStatementReturnStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ReturnStatement")

-- | DSL injection for the simple variant of hydra.ext.csharp.syntax.ReturnStatement
returnStatementSimple :: Typed.TypedTerm Syntax.ReturnStatement
returnStatementSimple =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ReturnStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "simple"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the value variant of hydra.ext.csharp.syntax.ReturnStatement
returnStatementValue :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.ReturnStatement
returnStatementValue x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ReturnStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "value"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the ref variant of hydra.ext.csharp.syntax.ReturnType
returnTypeRef :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.ReturnType
returnTypeRef x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ReturnType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "ref"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.ReturnType
returnTypeReturnType :: Typed.TypedName Syntax.ReturnType
returnTypeReturnType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ReturnType")

-- | DSL injection for the void variant of hydra.ext.csharp.syntax.ReturnType
returnTypeVoid :: Typed.TypedTerm Syntax.ReturnType
returnTypeVoid =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ReturnType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "void"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the interface variant of hydra.ext.csharp.syntax.SecondaryConstraint
secondaryConstraintInterface :: Typed.TypedTerm Syntax.InterfaceType -> Typed.TypedTerm Syntax.SecondaryConstraint
secondaryConstraintInterface x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SecondaryConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "interface"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the parameter variant of hydra.ext.csharp.syntax.SecondaryConstraint
secondaryConstraintParameter :: Typed.TypedTerm Syntax.TypeParameter -> Typed.TypedTerm Syntax.SecondaryConstraint
secondaryConstraintParameter x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SecondaryConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "parameter"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.SecondaryConstraint
secondaryConstraintSecondaryConstraint :: Typed.TypedName Syntax.SecondaryConstraint
secondaryConstraintSecondaryConstraint = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.SecondaryConstraint")

-- | DSL constructor for the hydra.ext.csharp.syntax.SecondaryConstraints wrapper
secondaryConstraints :: Typed.TypedTerm [Syntax.SecondaryConstraint] -> Typed.TypedTerm Syntax.SecondaryConstraints
secondaryConstraints x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.SecondaryConstraints"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.SecondaryConstraints
secondaryConstraintsSecondaryConstraints :: Typed.TypedName Syntax.SecondaryConstraints
secondaryConstraintsSecondaryConstraints = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.SecondaryConstraints")

-- | DSL injection for the group variant of hydra.ext.csharp.syntax.SelectOrGroupClause
selectOrGroupClauseGroup :: Typed.TypedTerm Syntax.GroupClause -> Typed.TypedTerm Syntax.SelectOrGroupClause
selectOrGroupClauseGroup x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SelectOrGroupClause"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "group"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the select variant of hydra.ext.csharp.syntax.SelectOrGroupClause
selectOrGroupClauseSelect :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SelectOrGroupClause
selectOrGroupClauseSelect x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SelectOrGroupClause"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "select"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.SelectOrGroupClause
selectOrGroupClauseSelectOrGroupClause :: Typed.TypedName Syntax.SelectOrGroupClause
selectOrGroupClauseSelectOrGroupClause = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.SelectOrGroupClause")

-- | DSL injection for the if variant of hydra.ext.csharp.syntax.SelectionStatement
selectionStatementIf :: Typed.TypedTerm Syntax.IfStatement -> Typed.TypedTerm Syntax.SelectionStatement
selectionStatementIf x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SelectionStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "if"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.SelectionStatement
selectionStatementSelectionStatement :: Typed.TypedName Syntax.SelectionStatement
selectionStatementSelectionStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.SelectionStatement")

-- | DSL injection for the switch variant of hydra.ext.csharp.syntax.SelectionStatement
selectionStatementSwitch :: Typed.TypedTerm Syntax.SwitchStatement -> Typed.TypedTerm Syntax.SelectionStatement
selectionStatementSwitch x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SelectionStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "switch"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the binary variant of hydra.ext.csharp.syntax.ShiftExpression
shiftExpressionBinary :: Typed.TypedTerm Syntax.BinaryShiftExpression -> Typed.TypedTerm Syntax.ShiftExpression
shiftExpressionBinary x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ShiftExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "binary"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.ShiftExpression
shiftExpressionShiftExpression :: Typed.TypedName Syntax.ShiftExpression
shiftExpressionShiftExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ShiftExpression")

-- | DSL injection for the simple variant of hydra.ext.csharp.syntax.ShiftExpression
shiftExpressionSimple :: Typed.TypedTerm Syntax.AdditiveExpression -> Typed.TypedTerm Syntax.ShiftExpression
shiftExpressionSimple x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ShiftExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "simple"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the left variant of hydra.ext.csharp.syntax.ShiftOperator
shiftOperatorLeft :: Typed.TypedTerm Syntax.ShiftOperator
shiftOperatorLeft =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ShiftOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "left"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the right variant of hydra.ext.csharp.syntax.ShiftOperator
shiftOperatorRight :: Typed.TypedTerm Syntax.ShiftOperator
shiftOperatorRight =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ShiftOperator"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "right"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.csharp.syntax.ShiftOperator
shiftOperatorShiftOperator :: Typed.TypedName Syntax.ShiftOperator
shiftOperatorShiftOperator = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ShiftOperator")

-- | DSL constructor for hydra.ext.csharp.syntax.SimpleConditionalExpression
simpleConditionalExpression :: Typed.TypedTerm Syntax.NullCoalescingExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SimpleConditionalExpression
simpleConditionalExpression condition true false =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleConditionalExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Typed.unTypedTerm condition)},
        Model.Field {
          Model.fieldName = (Model.Name "true"),
          Model.fieldTerm = (Typed.unTypedTerm true)},
        Model.Field {
          Model.fieldName = (Model.Name "false"),
          Model.fieldTerm = (Typed.unTypedTerm false)}]}))

-- | DSL accessor for the condition field of hydra.ext.csharp.syntax.SimpleConditionalExpression
simpleConditionalExpressionCondition :: Typed.TypedTerm Syntax.SimpleConditionalExpression -> Typed.TypedTerm Syntax.NullCoalescingExpression
simpleConditionalExpressionCondition x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleConditionalExpression"),
        Model.projectionFieldName = (Model.Name "condition")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the false field of hydra.ext.csharp.syntax.SimpleConditionalExpression
simpleConditionalExpressionFalse :: Typed.TypedTerm Syntax.SimpleConditionalExpression -> Typed.TypedTerm Syntax.Expression
simpleConditionalExpressionFalse x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleConditionalExpression"),
        Model.projectionFieldName = (Model.Name "false")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.SimpleConditionalExpression
simpleConditionalExpressionSimpleConditionalExpression :: Typed.TypedName Syntax.SimpleConditionalExpression
simpleConditionalExpressionSimpleConditionalExpression =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.SimpleConditionalExpression")

-- | DSL accessor for the true field of hydra.ext.csharp.syntax.SimpleConditionalExpression
simpleConditionalExpressionTrue :: Typed.TypedTerm Syntax.SimpleConditionalExpression -> Typed.TypedTerm Syntax.Expression
simpleConditionalExpressionTrue x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleConditionalExpression"),
        Model.projectionFieldName = (Model.Name "true")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the condition field of hydra.ext.csharp.syntax.SimpleConditionalExpression
simpleConditionalExpressionWithCondition :: Typed.TypedTerm Syntax.SimpleConditionalExpression -> Typed.TypedTerm Syntax.NullCoalescingExpression -> Typed.TypedTerm Syntax.SimpleConditionalExpression
simpleConditionalExpressionWithCondition original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleConditionalExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "true"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleConditionalExpression"),
              Model.projectionFieldName = (Model.Name "true")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "false"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleConditionalExpression"),
              Model.projectionFieldName = (Model.Name "false")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the false field of hydra.ext.csharp.syntax.SimpleConditionalExpression
simpleConditionalExpressionWithFalse :: Typed.TypedTerm Syntax.SimpleConditionalExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SimpleConditionalExpression
simpleConditionalExpressionWithFalse original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleConditionalExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleConditionalExpression"),
              Model.projectionFieldName = (Model.Name "condition")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "true"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleConditionalExpression"),
              Model.projectionFieldName = (Model.Name "true")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "false"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the true field of hydra.ext.csharp.syntax.SimpleConditionalExpression
simpleConditionalExpressionWithTrue :: Typed.TypedTerm Syntax.SimpleConditionalExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SimpleConditionalExpression
simpleConditionalExpressionWithTrue original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleConditionalExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleConditionalExpression"),
              Model.projectionFieldName = (Model.Name "condition")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "true"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "false"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleConditionalExpression"),
              Model.projectionFieldName = (Model.Name "false")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.SimpleName
simpleName :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.SimpleName
simpleName identifier typeArguments =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleName"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm identifier)},
        Model.Field {
          Model.fieldName = (Model.Name "typeArguments"),
          Model.fieldTerm = (Typed.unTypedTerm typeArguments)}]}))

-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.SimpleName
simpleNameIdentifier :: Typed.TypedTerm Syntax.SimpleName -> Typed.TypedTerm Syntax.Identifier
simpleNameIdentifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleName"),
        Model.projectionFieldName = (Model.Name "identifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.SimpleName
simpleNameSimpleName :: Typed.TypedName Syntax.SimpleName
simpleNameSimpleName = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.SimpleName")

-- | DSL accessor for the typeArguments field of hydra.ext.csharp.syntax.SimpleName
simpleNameTypeArguments :: Typed.TypedTerm Syntax.SimpleName -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList)
simpleNameTypeArguments x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleName"),
        Model.projectionFieldName = (Model.Name "typeArguments")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.SimpleName
simpleNameWithIdentifier :: Typed.TypedTerm Syntax.SimpleName -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.SimpleName
simpleNameWithIdentifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleName"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "typeArguments"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleName"),
              Model.projectionFieldName = (Model.Name "typeArguments")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the typeArguments field of hydra.ext.csharp.syntax.SimpleName
simpleNameWithTypeArguments :: Typed.TypedTerm Syntax.SimpleName -> Typed.TypedTerm (Maybe Syntax.TypeArgumentList) -> Typed.TypedTerm Syntax.SimpleName
simpleNameWithTypeArguments original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleName"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleName"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeArguments"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the bool variant of hydra.ext.csharp.syntax.SimpleType
simpleTypeBool :: Typed.TypedTerm Syntax.SimpleType
simpleTypeBool =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "bool"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the numeric variant of hydra.ext.csharp.syntax.SimpleType
simpleTypeNumeric :: Typed.TypedTerm Syntax.NumericType -> Typed.TypedTerm Syntax.SimpleType
simpleTypeNumeric x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SimpleType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "numeric"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.SimpleType
simpleTypeSimpleType :: Typed.TypedName Syntax.SimpleType
simpleTypeSimpleType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.SimpleType")

-- | DSL constructor for hydra.ext.csharp.syntax.SpecificCatchClause
specificCatchClause :: Typed.TypedTerm (Maybe Syntax.ExceptionSpecifier) -> Typed.TypedTerm (Maybe Syntax.BooleanExpression) -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.SpecificCatchClause
specificCatchClause specifier filter body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SpecificCatchClause"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "specifier"),
          Model.fieldTerm = (Typed.unTypedTerm specifier)},
        Model.Field {
          Model.fieldName = (Model.Name "filter"),
          Model.fieldTerm = (Typed.unTypedTerm filter)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.SpecificCatchClause
specificCatchClauseBody :: Typed.TypedTerm Syntax.SpecificCatchClause -> Typed.TypedTerm Syntax.Block
specificCatchClauseBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SpecificCatchClause"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the filter field of hydra.ext.csharp.syntax.SpecificCatchClause
specificCatchClauseFilter :: Typed.TypedTerm Syntax.SpecificCatchClause -> Typed.TypedTerm (Maybe Syntax.BooleanExpression)
specificCatchClauseFilter x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SpecificCatchClause"),
        Model.projectionFieldName = (Model.Name "filter")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.SpecificCatchClause
specificCatchClauseSpecificCatchClause :: Typed.TypedName Syntax.SpecificCatchClause
specificCatchClauseSpecificCatchClause = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.SpecificCatchClause")

-- | DSL accessor for the specifier field of hydra.ext.csharp.syntax.SpecificCatchClause
specificCatchClauseSpecifier :: Typed.TypedTerm Syntax.SpecificCatchClause -> Typed.TypedTerm (Maybe Syntax.ExceptionSpecifier)
specificCatchClauseSpecifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SpecificCatchClause"),
        Model.projectionFieldName = (Model.Name "specifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the body field of hydra.ext.csharp.syntax.SpecificCatchClause
specificCatchClauseWithBody :: Typed.TypedTerm Syntax.SpecificCatchClause -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.SpecificCatchClause
specificCatchClauseWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SpecificCatchClause"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "specifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SpecificCatchClause"),
              Model.projectionFieldName = (Model.Name "specifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "filter"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SpecificCatchClause"),
              Model.projectionFieldName = (Model.Name "filter")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the filter field of hydra.ext.csharp.syntax.SpecificCatchClause
specificCatchClauseWithFilter :: Typed.TypedTerm Syntax.SpecificCatchClause -> Typed.TypedTerm (Maybe Syntax.BooleanExpression) -> Typed.TypedTerm Syntax.SpecificCatchClause
specificCatchClauseWithFilter original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SpecificCatchClause"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "specifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SpecificCatchClause"),
              Model.projectionFieldName = (Model.Name "specifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "filter"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SpecificCatchClause"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the specifier field of hydra.ext.csharp.syntax.SpecificCatchClause
specificCatchClauseWithSpecifier :: Typed.TypedTerm Syntax.SpecificCatchClause -> Typed.TypedTerm (Maybe Syntax.ExceptionSpecifier) -> Typed.TypedTerm Syntax.SpecificCatchClause
specificCatchClauseWithSpecifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SpecificCatchClause"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "specifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "filter"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SpecificCatchClause"),
              Model.projectionFieldName = (Model.Name "filter")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SpecificCatchClause"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.StackallocExpression
stackallocExpression :: Typed.TypedTerm (Maybe Syntax.UnmanagedType) -> Typed.TypedTerm (Maybe Syntax.ConstantExpression) -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.StackallocExpression
stackallocExpression type_ expression initializer =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StackallocExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm expression)},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Typed.unTypedTerm initializer)}]}))

-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.StackallocExpression
stackallocExpressionExpression :: Typed.TypedTerm Syntax.StackallocExpression -> Typed.TypedTerm (Maybe Syntax.ConstantExpression)
stackallocExpressionExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StackallocExpression"),
        Model.projectionFieldName = (Model.Name "expression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the initializer field of hydra.ext.csharp.syntax.StackallocExpression
stackallocExpressionInitializer :: Typed.TypedTerm Syntax.StackallocExpression -> Typed.TypedTerm [Syntax.Expression]
stackallocExpressionInitializer x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StackallocExpression"),
        Model.projectionFieldName = (Model.Name "initializer")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.StackallocExpression
stackallocExpressionStackallocExpression :: Typed.TypedName Syntax.StackallocExpression
stackallocExpressionStackallocExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StackallocExpression")

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.StackallocExpression
stackallocExpressionType :: Typed.TypedTerm Syntax.StackallocExpression -> Typed.TypedTerm (Maybe Syntax.UnmanagedType)
stackallocExpressionType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StackallocExpression"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the expression field of hydra.ext.csharp.syntax.StackallocExpression
stackallocExpressionWithExpression :: Typed.TypedTerm Syntax.StackallocExpression -> Typed.TypedTerm (Maybe Syntax.ConstantExpression) -> Typed.TypedTerm Syntax.StackallocExpression
stackallocExpressionWithExpression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StackallocExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StackallocExpression"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StackallocExpression"),
              Model.projectionFieldName = (Model.Name "initializer")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the initializer field of hydra.ext.csharp.syntax.StackallocExpression
stackallocExpressionWithInitializer :: Typed.TypedTerm Syntax.StackallocExpression -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.StackallocExpression
stackallocExpressionWithInitializer original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StackallocExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StackallocExpression"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StackallocExpression"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.StackallocExpression
stackallocExpressionWithType :: Typed.TypedTerm Syntax.StackallocExpression -> Typed.TypedTerm (Maybe Syntax.UnmanagedType) -> Typed.TypedTerm Syntax.StackallocExpression
stackallocExpressionWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StackallocExpression"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StackallocExpression"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StackallocExpression"),
              Model.projectionFieldName = (Model.Name "initializer")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.StandardEventDeclaration
standardEventDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.EventModifier] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.VariableDeclarators -> Typed.TypedTerm Syntax.StandardEventDeclaration
standardEventDeclaration attributes modifiers type_ declarators =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm modifiers)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Typed.unTypedTerm declarators)}]}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.StandardEventDeclaration
standardEventDeclarationAttributes :: Typed.TypedTerm Syntax.StandardEventDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes)
standardEventDeclarationAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the declarators field of hydra.ext.csharp.syntax.StandardEventDeclaration
standardEventDeclarationDeclarators :: Typed.TypedTerm Syntax.StandardEventDeclaration -> Typed.TypedTerm Syntax.VariableDeclarators
standardEventDeclarationDeclarators x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"),
        Model.projectionFieldName = (Model.Name "declarators")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.StandardEventDeclaration
standardEventDeclarationModifiers :: Typed.TypedTerm Syntax.StandardEventDeclaration -> Typed.TypedTerm [Syntax.EventModifier]
standardEventDeclarationModifiers x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"),
        Model.projectionFieldName = (Model.Name "modifiers")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.StandardEventDeclaration
standardEventDeclarationStandardEventDeclaration :: Typed.TypedName Syntax.StandardEventDeclaration
standardEventDeclarationStandardEventDeclaration =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration")

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.StandardEventDeclaration
standardEventDeclarationType :: Typed.TypedTerm Syntax.StandardEventDeclaration -> Typed.TypedTerm Syntax.Type
standardEventDeclarationType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.StandardEventDeclaration
standardEventDeclarationWithAttributes :: Typed.TypedTerm Syntax.StandardEventDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.StandardEventDeclaration
standardEventDeclarationWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"),
              Model.projectionFieldName = (Model.Name "declarators")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the declarators field of hydra.ext.csharp.syntax.StandardEventDeclaration
standardEventDeclarationWithDeclarators :: Typed.TypedTerm Syntax.StandardEventDeclaration -> Typed.TypedTerm Syntax.VariableDeclarators -> Typed.TypedTerm Syntax.StandardEventDeclaration
standardEventDeclarationWithDeclarators original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.StandardEventDeclaration
standardEventDeclarationWithModifiers :: Typed.TypedTerm Syntax.StandardEventDeclaration -> Typed.TypedTerm [Syntax.EventModifier] -> Typed.TypedTerm Syntax.StandardEventDeclaration
standardEventDeclarationWithModifiers original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"),
              Model.projectionFieldName = (Model.Name "declarators")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.StandardEventDeclaration
standardEventDeclarationWithType :: Typed.TypedTerm Syntax.StandardEventDeclaration -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.StandardEventDeclaration
standardEventDeclarationWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "declarators"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardEventDeclaration"),
              Model.projectionFieldName = (Model.Name "declarators")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.StandardIndexerDeclaration
standardIndexerDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.IndexerModifier] -> Typed.TypedTerm Syntax.IndexerDeclarator -> Typed.TypedTerm Syntax.IndexerBody -> Typed.TypedTerm Syntax.StandardIndexerDeclaration
standardIndexerDeclaration attributes modifiers declarator body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm modifiers)},
        Model.Field {
          Model.fieldName = (Model.Name "declarator"),
          Model.fieldTerm = (Typed.unTypedTerm declarator)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.StandardIndexerDeclaration
standardIndexerDeclarationAttributes :: Typed.TypedTerm Syntax.StandardIndexerDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes)
standardIndexerDeclarationAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.StandardIndexerDeclaration
standardIndexerDeclarationBody :: Typed.TypedTerm Syntax.StandardIndexerDeclaration -> Typed.TypedTerm Syntax.IndexerBody
standardIndexerDeclarationBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the declarator field of hydra.ext.csharp.syntax.StandardIndexerDeclaration
standardIndexerDeclarationDeclarator :: Typed.TypedTerm Syntax.StandardIndexerDeclaration -> Typed.TypedTerm Syntax.IndexerDeclarator
standardIndexerDeclarationDeclarator x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"),
        Model.projectionFieldName = (Model.Name "declarator")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.StandardIndexerDeclaration
standardIndexerDeclarationModifiers :: Typed.TypedTerm Syntax.StandardIndexerDeclaration -> Typed.TypedTerm [Syntax.IndexerModifier]
standardIndexerDeclarationModifiers x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"),
        Model.projectionFieldName = (Model.Name "modifiers")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.StandardIndexerDeclaration
standardIndexerDeclarationStandardIndexerDeclaration :: Typed.TypedName Syntax.StandardIndexerDeclaration
standardIndexerDeclarationStandardIndexerDeclaration =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration")

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.StandardIndexerDeclaration
standardIndexerDeclarationWithAttributes :: Typed.TypedTerm Syntax.StandardIndexerDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.StandardIndexerDeclaration
standardIndexerDeclarationWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "declarator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the body field of hydra.ext.csharp.syntax.StandardIndexerDeclaration
standardIndexerDeclarationWithBody :: Typed.TypedTerm Syntax.StandardIndexerDeclaration -> Typed.TypedTerm Syntax.IndexerBody -> Typed.TypedTerm Syntax.StandardIndexerDeclaration
standardIndexerDeclarationWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "declarator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the declarator field of hydra.ext.csharp.syntax.StandardIndexerDeclaration
standardIndexerDeclarationWithDeclarator :: Typed.TypedTerm Syntax.StandardIndexerDeclaration -> Typed.TypedTerm Syntax.IndexerDeclarator -> Typed.TypedTerm Syntax.StandardIndexerDeclaration
standardIndexerDeclarationWithDeclarator original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "declarator"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.StandardIndexerDeclaration
standardIndexerDeclarationWithModifiers :: Typed.TypedTerm Syntax.StandardIndexerDeclaration -> Typed.TypedTerm [Syntax.IndexerModifier] -> Typed.TypedTerm Syntax.StandardIndexerDeclaration
standardIndexerDeclarationWithModifiers original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "declarator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "declarator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardIndexerDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration
standardLocalFunctionDeclaration :: Typed.TypedTerm [Syntax.LocalFunctionModifier] -> Typed.TypedTerm Syntax.ReturnType -> Typed.TypedTerm Syntax.LocalFunctionHeader -> Typed.TypedTerm Syntax.LocalFunctionBody -> Typed.TypedTerm Syntax.StandardLocalFunctionDeclaration
standardLocalFunctionDeclaration modifiers returnType header body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm modifiers)},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Typed.unTypedTerm returnType)},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Typed.unTypedTerm header)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration
standardLocalFunctionDeclarationBody :: Typed.TypedTerm Syntax.StandardLocalFunctionDeclaration -> Typed.TypedTerm Syntax.LocalFunctionBody
standardLocalFunctionDeclarationBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the header field of hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration
standardLocalFunctionDeclarationHeader :: Typed.TypedTerm Syntax.StandardLocalFunctionDeclaration -> Typed.TypedTerm Syntax.LocalFunctionHeader
standardLocalFunctionDeclarationHeader x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"),
        Model.projectionFieldName = (Model.Name "header")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration
standardLocalFunctionDeclarationModifiers :: Typed.TypedTerm Syntax.StandardLocalFunctionDeclaration -> Typed.TypedTerm [Syntax.LocalFunctionModifier]
standardLocalFunctionDeclarationModifiers x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"),
        Model.projectionFieldName = (Model.Name "modifiers")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the returnType field of hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration
standardLocalFunctionDeclarationReturnType :: Typed.TypedTerm Syntax.StandardLocalFunctionDeclaration -> Typed.TypedTerm Syntax.ReturnType
standardLocalFunctionDeclarationReturnType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"),
        Model.projectionFieldName = (Model.Name "returnType")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration
standardLocalFunctionDeclarationStandardLocalFunctionDeclaration :: Typed.TypedName Syntax.StandardLocalFunctionDeclaration
standardLocalFunctionDeclarationStandardLocalFunctionDeclaration =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration")

-- | DSL updater for the body field of hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration
standardLocalFunctionDeclarationWithBody :: Typed.TypedTerm Syntax.StandardLocalFunctionDeclaration -> Typed.TypedTerm Syntax.LocalFunctionBody -> Typed.TypedTerm Syntax.StandardLocalFunctionDeclaration
standardLocalFunctionDeclarationWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "header")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the header field of hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration
standardLocalFunctionDeclarationWithHeader :: Typed.TypedTerm Syntax.StandardLocalFunctionDeclaration -> Typed.TypedTerm Syntax.LocalFunctionHeader -> Typed.TypedTerm Syntax.StandardLocalFunctionDeclaration
standardLocalFunctionDeclarationWithHeader original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration
standardLocalFunctionDeclarationWithModifiers :: Typed.TypedTerm Syntax.StandardLocalFunctionDeclaration -> Typed.TypedTerm [Syntax.LocalFunctionModifier] -> Typed.TypedTerm Syntax.StandardLocalFunctionDeclaration
standardLocalFunctionDeclarationWithModifiers original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "header")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the returnType field of hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration
standardLocalFunctionDeclarationWithReturnType :: Typed.TypedTerm Syntax.StandardLocalFunctionDeclaration -> Typed.TypedTerm Syntax.ReturnType -> Typed.TypedTerm Syntax.StandardLocalFunctionDeclaration
standardLocalFunctionDeclarationWithReturnType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "header")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardLocalFunctionDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.StandardMethodDeclaration
standardMethodDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.MethodModifier] -> Typed.TypedTerm Syntax.ReturnType -> Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm Syntax.MethodBody -> Typed.TypedTerm Syntax.StandardMethodDeclaration
standardMethodDeclaration attributes modifiers returnType header body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm modifiers)},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Typed.unTypedTerm returnType)},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Typed.unTypedTerm header)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.StandardMethodDeclaration
standardMethodDeclarationAttributes :: Typed.TypedTerm Syntax.StandardMethodDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes)
standardMethodDeclarationAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.StandardMethodDeclaration
standardMethodDeclarationBody :: Typed.TypedTerm Syntax.StandardMethodDeclaration -> Typed.TypedTerm Syntax.MethodBody
standardMethodDeclarationBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the header field of hydra.ext.csharp.syntax.StandardMethodDeclaration
standardMethodDeclarationHeader :: Typed.TypedTerm Syntax.StandardMethodDeclaration -> Typed.TypedTerm Syntax.MethodHeader
standardMethodDeclarationHeader x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"),
        Model.projectionFieldName = (Model.Name "header")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.StandardMethodDeclaration
standardMethodDeclarationModifiers :: Typed.TypedTerm Syntax.StandardMethodDeclaration -> Typed.TypedTerm [Syntax.MethodModifier]
standardMethodDeclarationModifiers x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"),
        Model.projectionFieldName = (Model.Name "modifiers")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the returnType field of hydra.ext.csharp.syntax.StandardMethodDeclaration
standardMethodDeclarationReturnType :: Typed.TypedTerm Syntax.StandardMethodDeclaration -> Typed.TypedTerm Syntax.ReturnType
standardMethodDeclarationReturnType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"),
        Model.projectionFieldName = (Model.Name "returnType")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.StandardMethodDeclaration
standardMethodDeclarationStandardMethodDeclaration :: Typed.TypedName Syntax.StandardMethodDeclaration
standardMethodDeclarationStandardMethodDeclaration =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration")

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.StandardMethodDeclaration
standardMethodDeclarationWithAttributes :: Typed.TypedTerm Syntax.StandardMethodDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.StandardMethodDeclaration
standardMethodDeclarationWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "header")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the body field of hydra.ext.csharp.syntax.StandardMethodDeclaration
standardMethodDeclarationWithBody :: Typed.TypedTerm Syntax.StandardMethodDeclaration -> Typed.TypedTerm Syntax.MethodBody -> Typed.TypedTerm Syntax.StandardMethodDeclaration
standardMethodDeclarationWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "header")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the header field of hydra.ext.csharp.syntax.StandardMethodDeclaration
standardMethodDeclarationWithHeader :: Typed.TypedTerm Syntax.StandardMethodDeclaration -> Typed.TypedTerm Syntax.MethodHeader -> Typed.TypedTerm Syntax.StandardMethodDeclaration
standardMethodDeclarationWithHeader original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.StandardMethodDeclaration
standardMethodDeclarationWithModifiers :: Typed.TypedTerm Syntax.StandardMethodDeclaration -> Typed.TypedTerm [Syntax.MethodModifier] -> Typed.TypedTerm Syntax.StandardMethodDeclaration
standardMethodDeclarationWithModifiers original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "returnType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "header")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the returnType field of hydra.ext.csharp.syntax.StandardMethodDeclaration
standardMethodDeclarationWithReturnType :: Typed.TypedTerm Syntax.StandardMethodDeclaration -> Typed.TypedTerm Syntax.ReturnType -> Typed.TypedTerm Syntax.StandardMethodDeclaration
standardMethodDeclarationWithReturnType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "returnType"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "header"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "header")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardMethodDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.StandardPropertyDeclaration
standardPropertyDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.PropertyModifier] -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.MemberName -> Typed.TypedTerm Syntax.PropertyBody -> Typed.TypedTerm Syntax.StandardPropertyDeclaration
standardPropertyDeclaration attributes modifiers type_ name body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm modifiers)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.StandardPropertyDeclaration
standardPropertyDeclarationAttributes :: Typed.TypedTerm Syntax.StandardPropertyDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes)
standardPropertyDeclarationAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.StandardPropertyDeclaration
standardPropertyDeclarationBody :: Typed.TypedTerm Syntax.StandardPropertyDeclaration -> Typed.TypedTerm Syntax.PropertyBody
standardPropertyDeclarationBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.StandardPropertyDeclaration
standardPropertyDeclarationModifiers :: Typed.TypedTerm Syntax.StandardPropertyDeclaration -> Typed.TypedTerm [Syntax.PropertyModifier]
standardPropertyDeclarationModifiers x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"),
        Model.projectionFieldName = (Model.Name "modifiers")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the name field of hydra.ext.csharp.syntax.StandardPropertyDeclaration
standardPropertyDeclarationName :: Typed.TypedTerm Syntax.StandardPropertyDeclaration -> Typed.TypedTerm Syntax.MemberName
standardPropertyDeclarationName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.StandardPropertyDeclaration
standardPropertyDeclarationStandardPropertyDeclaration :: Typed.TypedName Syntax.StandardPropertyDeclaration
standardPropertyDeclarationStandardPropertyDeclaration =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration")

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.StandardPropertyDeclaration
standardPropertyDeclarationType :: Typed.TypedTerm Syntax.StandardPropertyDeclaration -> Typed.TypedTerm Syntax.Type
standardPropertyDeclarationType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.StandardPropertyDeclaration
standardPropertyDeclarationWithAttributes :: Typed.TypedTerm Syntax.StandardPropertyDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.StandardPropertyDeclaration
standardPropertyDeclarationWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the body field of hydra.ext.csharp.syntax.StandardPropertyDeclaration
standardPropertyDeclarationWithBody :: Typed.TypedTerm Syntax.StandardPropertyDeclaration -> Typed.TypedTerm Syntax.PropertyBody -> Typed.TypedTerm Syntax.StandardPropertyDeclaration
standardPropertyDeclarationWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.StandardPropertyDeclaration
standardPropertyDeclarationWithModifiers :: Typed.TypedTerm Syntax.StandardPropertyDeclaration -> Typed.TypedTerm [Syntax.PropertyModifier] -> Typed.TypedTerm Syntax.StandardPropertyDeclaration
standardPropertyDeclarationWithModifiers original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.csharp.syntax.StandardPropertyDeclaration
standardPropertyDeclarationWithName :: Typed.TypedTerm Syntax.StandardPropertyDeclaration -> Typed.TypedTerm Syntax.MemberName -> Typed.TypedTerm Syntax.StandardPropertyDeclaration
standardPropertyDeclarationWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.StandardPropertyDeclaration
standardPropertyDeclarationWithType :: Typed.TypedTerm Syntax.StandardPropertyDeclaration -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.StandardPropertyDeclaration
standardPropertyDeclarationWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StandardPropertyDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the declaration variant of hydra.ext.csharp.syntax.Statement
statementDeclaration :: Typed.TypedTerm Syntax.DeclarationStatement -> Typed.TypedTerm Syntax.Statement
statementDeclaration x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Statement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "declaration"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the embedded variant of hydra.ext.csharp.syntax.Statement
statementEmbedded :: Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.Statement
statementEmbedded x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Statement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "embedded"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the assignment variant of hydra.ext.csharp.syntax.StatementExpression
statementExpressionAssignment :: Typed.TypedTerm Syntax.Assignment -> Typed.TypedTerm Syntax.StatementExpression
statementExpressionAssignment x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StatementExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "assignment"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the await variant of hydra.ext.csharp.syntax.StatementExpression
statementExpressionAwait :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.StatementExpression
statementExpressionAwait x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StatementExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "await"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the invocation variant of hydra.ext.csharp.syntax.StatementExpression
statementExpressionInvocation :: Typed.TypedTerm Syntax.InvocationExpression -> Typed.TypedTerm Syntax.StatementExpression
statementExpressionInvocation x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StatementExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "invocation"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for the hydra.ext.csharp.syntax.StatementExpressionList wrapper
statementExpressionList :: Typed.TypedTerm [Syntax.StatementExpression] -> Typed.TypedTerm Syntax.StatementExpressionList
statementExpressionList x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.StatementExpressionList"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.StatementExpressionList
statementExpressionListStatementExpressionList :: Typed.TypedName Syntax.StatementExpressionList
statementExpressionListStatementExpressionList =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StatementExpressionList")

-- | DSL injection for the nullConditionalInvocation variant of hydra.ext.csharp.syntax.StatementExpression
statementExpressionNullConditionalInvocation :: Typed.TypedTerm Syntax.NullConditionalInvocationExpression -> Typed.TypedTerm Syntax.StatementExpression
statementExpressionNullConditionalInvocation x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StatementExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "nullConditionalInvocation"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the objectCreation variant of hydra.ext.csharp.syntax.StatementExpression
statementExpressionObjectCreation :: Typed.TypedTerm Syntax.ObjectCreationExpression -> Typed.TypedTerm Syntax.StatementExpression
statementExpressionObjectCreation x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StatementExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "objectCreation"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the postDecrement variant of hydra.ext.csharp.syntax.StatementExpression
statementExpressionPostDecrement :: Typed.TypedTerm Syntax.PrimaryExpression -> Typed.TypedTerm Syntax.StatementExpression
statementExpressionPostDecrement x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StatementExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "postDecrement"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the postIncrement variant of hydra.ext.csharp.syntax.StatementExpression
statementExpressionPostIncrement :: Typed.TypedTerm Syntax.PrimaryExpression -> Typed.TypedTerm Syntax.StatementExpression
statementExpressionPostIncrement x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StatementExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "postIncrement"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the preDecrement variant of hydra.ext.csharp.syntax.StatementExpression
statementExpressionPreDecrement :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.StatementExpression
statementExpressionPreDecrement x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StatementExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "preDecrement"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the preIncrement variant of hydra.ext.csharp.syntax.StatementExpression
statementExpressionPreIncrement :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.StatementExpression
statementExpressionPreIncrement x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StatementExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "preIncrement"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.StatementExpression
statementExpressionStatementExpression :: Typed.TypedName Syntax.StatementExpression
statementExpressionStatementExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StatementExpression")

-- | DSL injection for the labeled variant of hydra.ext.csharp.syntax.Statement
statementLabeled :: Typed.TypedTerm Syntax.LabeledStatement -> Typed.TypedTerm Syntax.Statement
statementLabeled x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Statement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "labeled"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.Statement
statementStatement :: Typed.TypedName Syntax.Statement
statementStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.Statement")

-- | DSL injection for the block variant of hydra.ext.csharp.syntax.StaticConstructorBody
staticConstructorBodyBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.StaticConstructorBody
staticConstructorBodyBlock x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "block"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the empty variant of hydra.ext.csharp.syntax.StaticConstructorBody
staticConstructorBodyEmpty :: Typed.TypedTerm Syntax.StaticConstructorBody
staticConstructorBodyEmpty =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "empty"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.StaticConstructorBody
staticConstructorBodyExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.StaticConstructorBody
staticConstructorBodyExpression x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorBody"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "expression"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.StaticConstructorBody
staticConstructorBodyStaticConstructorBody :: Typed.TypedName Syntax.StaticConstructorBody
staticConstructorBodyStaticConstructorBody = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StaticConstructorBody")

-- | DSL constructor for hydra.ext.csharp.syntax.StaticConstructorDeclaration
staticConstructorDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.StaticConstructorModifiers -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.StaticConstructorBody -> Typed.TypedTerm Syntax.StaticConstructorDeclaration
staticConstructorDeclaration attributes modifiers name body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm modifiers)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.StaticConstructorDeclaration
staticConstructorDeclarationAttributes :: Typed.TypedTerm Syntax.StaticConstructorDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes)
staticConstructorDeclarationAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.StaticConstructorDeclaration
staticConstructorDeclarationBody :: Typed.TypedTerm Syntax.StaticConstructorDeclaration -> Typed.TypedTerm Syntax.StaticConstructorBody
staticConstructorDeclarationBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.StaticConstructorDeclaration
staticConstructorDeclarationModifiers :: Typed.TypedTerm Syntax.StaticConstructorDeclaration -> Typed.TypedTerm Syntax.StaticConstructorModifiers
staticConstructorDeclarationModifiers x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"),
        Model.projectionFieldName = (Model.Name "modifiers")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the name field of hydra.ext.csharp.syntax.StaticConstructorDeclaration
staticConstructorDeclarationName :: Typed.TypedTerm Syntax.StaticConstructorDeclaration -> Typed.TypedTerm Syntax.Identifier
staticConstructorDeclarationName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.StaticConstructorDeclaration
staticConstructorDeclarationStaticConstructorDeclaration :: Typed.TypedName Syntax.StaticConstructorDeclaration
staticConstructorDeclarationStaticConstructorDeclaration =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration")

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.StaticConstructorDeclaration
staticConstructorDeclarationWithAttributes :: Typed.TypedTerm Syntax.StaticConstructorDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.StaticConstructorDeclaration
staticConstructorDeclarationWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the body field of hydra.ext.csharp.syntax.StaticConstructorDeclaration
staticConstructorDeclarationWithBody :: Typed.TypedTerm Syntax.StaticConstructorDeclaration -> Typed.TypedTerm Syntax.StaticConstructorBody -> Typed.TypedTerm Syntax.StaticConstructorDeclaration
staticConstructorDeclarationWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.StaticConstructorDeclaration
staticConstructorDeclarationWithModifiers :: Typed.TypedTerm Syntax.StaticConstructorDeclaration -> Typed.TypedTerm Syntax.StaticConstructorModifiers -> Typed.TypedTerm Syntax.StaticConstructorDeclaration
staticConstructorDeclarationWithModifiers original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.csharp.syntax.StaticConstructorDeclaration
staticConstructorDeclarationWithName :: Typed.TypedTerm Syntax.StaticConstructorDeclaration -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.StaticConstructorDeclaration
staticConstructorDeclarationWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.StaticConstructorModifiers
staticConstructorModifiers :: Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.StaticConstructorModifiers
staticConstructorModifiers extern unsafe =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorModifiers"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "extern"),
          Model.fieldTerm = (Typed.unTypedTerm extern)},
        Model.Field {
          Model.fieldName = (Model.Name "unsafe"),
          Model.fieldTerm = (Typed.unTypedTerm unsafe)}]}))

-- | DSL accessor for the extern field of hydra.ext.csharp.syntax.StaticConstructorModifiers
staticConstructorModifiersExtern :: Typed.TypedTerm Syntax.StaticConstructorModifiers -> Typed.TypedTerm Bool
staticConstructorModifiersExtern x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorModifiers"),
        Model.projectionFieldName = (Model.Name "extern")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.StaticConstructorModifiers
staticConstructorModifiersStaticConstructorModifiers :: Typed.TypedName Syntax.StaticConstructorModifiers
staticConstructorModifiersStaticConstructorModifiers =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StaticConstructorModifiers")

-- | DSL accessor for the unsafe field of hydra.ext.csharp.syntax.StaticConstructorModifiers
staticConstructorModifiersUnsafe :: Typed.TypedTerm Syntax.StaticConstructorModifiers -> Typed.TypedTerm Bool
staticConstructorModifiersUnsafe x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorModifiers"),
        Model.projectionFieldName = (Model.Name "unsafe")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the extern field of hydra.ext.csharp.syntax.StaticConstructorModifiers
staticConstructorModifiersWithExtern :: Typed.TypedTerm Syntax.StaticConstructorModifiers -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.StaticConstructorModifiers
staticConstructorModifiersWithExtern original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorModifiers"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "extern"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "unsafe"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorModifiers"),
              Model.projectionFieldName = (Model.Name "unsafe")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the unsafe field of hydra.ext.csharp.syntax.StaticConstructorModifiers
staticConstructorModifiersWithUnsafe :: Typed.TypedTerm Syntax.StaticConstructorModifiers -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.StaticConstructorModifiers
staticConstructorModifiersWithUnsafe original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorModifiers"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "extern"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StaticConstructorModifiers"),
              Model.projectionFieldName = (Model.Name "extern")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "unsafe"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.StructDeclaration
structDeclaration :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm [Syntax.StructModifier] -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.TypeParameterList) -> Typed.TypedTerm [Syntax.InterfaceType] -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] -> Typed.TypedTerm [Syntax.StructMemberDeclaration] -> Typed.TypedTerm Syntax.StructDeclaration
structDeclaration attributes modifiers ref partial name parameters interfaces constraints body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm modifiers)},
        Model.Field {
          Model.fieldName = (Model.Name "ref"),
          Model.fieldTerm = (Typed.unTypedTerm ref)},
        Model.Field {
          Model.fieldName = (Model.Name "partial"),
          Model.fieldTerm = (Typed.unTypedTerm partial)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm parameters)},
        Model.Field {
          Model.fieldName = (Model.Name "interfaces"),
          Model.fieldTerm = (Typed.unTypedTerm interfaces)},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Typed.unTypedTerm constraints)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.StructDeclaration
structDeclarationAttributes :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes)
structDeclarationAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.StructDeclaration
structDeclarationBody :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm [Syntax.StructMemberDeclaration]
structDeclarationBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the constraints field of hydra.ext.csharp.syntax.StructDeclaration
structDeclarationConstraints :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause]
structDeclarationConstraints x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
        Model.projectionFieldName = (Model.Name "constraints")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the interfaces field of hydra.ext.csharp.syntax.StructDeclaration
structDeclarationInterfaces :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm [Syntax.InterfaceType]
structDeclarationInterfaces x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
        Model.projectionFieldName = (Model.Name "interfaces")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the modifiers field of hydra.ext.csharp.syntax.StructDeclaration
structDeclarationModifiers :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm [Syntax.StructModifier]
structDeclarationModifiers x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
        Model.projectionFieldName = (Model.Name "modifiers")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the name field of hydra.ext.csharp.syntax.StructDeclaration
structDeclarationName :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm Syntax.Identifier
structDeclarationName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the parameters field of hydra.ext.csharp.syntax.StructDeclaration
structDeclarationParameters :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm (Maybe Syntax.TypeParameterList)
structDeclarationParameters x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
        Model.projectionFieldName = (Model.Name "parameters")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the partial field of hydra.ext.csharp.syntax.StructDeclaration
structDeclarationPartial :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm Bool
structDeclarationPartial x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
        Model.projectionFieldName = (Model.Name "partial")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the ref field of hydra.ext.csharp.syntax.StructDeclaration
structDeclarationRef :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm Bool
structDeclarationRef x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
        Model.projectionFieldName = (Model.Name "ref")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.StructDeclaration
structDeclarationStructDeclaration :: Typed.TypedName Syntax.StructDeclaration
structDeclarationStructDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StructDeclaration")

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.StructDeclaration
structDeclarationWithAttributes :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.StructDeclaration
structDeclarationWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "ref"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "ref")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "partial"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "partial")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "interfaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "interfaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the body field of hydra.ext.csharp.syntax.StructDeclaration
structDeclarationWithBody :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm [Syntax.StructMemberDeclaration] -> Typed.TypedTerm Syntax.StructDeclaration
structDeclarationWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "ref"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "ref")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "partial"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "partial")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "interfaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "interfaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the constraints field of hydra.ext.csharp.syntax.StructDeclaration
structDeclarationWithConstraints :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm [Syntax.TypeParameterConstraintsClause] -> Typed.TypedTerm Syntax.StructDeclaration
structDeclarationWithConstraints original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "ref"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "ref")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "partial"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "partial")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "interfaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "interfaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the interfaces field of hydra.ext.csharp.syntax.StructDeclaration
structDeclarationWithInterfaces :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm [Syntax.InterfaceType] -> Typed.TypedTerm Syntax.StructDeclaration
structDeclarationWithInterfaces original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "ref"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "ref")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "partial"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "partial")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "interfaces"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the modifiers field of hydra.ext.csharp.syntax.StructDeclaration
structDeclarationWithModifiers :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm [Syntax.StructModifier] -> Typed.TypedTerm Syntax.StructDeclaration
structDeclarationWithModifiers original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "ref"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "ref")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "partial"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "partial")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "interfaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "interfaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.csharp.syntax.StructDeclaration
structDeclarationWithName :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.StructDeclaration
structDeclarationWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "ref"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "ref")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "partial"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "partial")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "interfaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "interfaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the parameters field of hydra.ext.csharp.syntax.StructDeclaration
structDeclarationWithParameters :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm (Maybe Syntax.TypeParameterList) -> Typed.TypedTerm Syntax.StructDeclaration
structDeclarationWithParameters original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "ref"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "ref")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "partial"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "partial")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "interfaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "interfaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the partial field of hydra.ext.csharp.syntax.StructDeclaration
structDeclarationWithPartial :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.StructDeclaration
structDeclarationWithPartial original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "ref"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "ref")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "partial"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "interfaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "interfaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the ref field of hydra.ext.csharp.syntax.StructDeclaration
structDeclarationWithRef :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.StructDeclaration
structDeclarationWithRef original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modifiers"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "modifiers")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "ref"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "partial"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "partial")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameters"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "parameters")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "interfaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "interfaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructDeclaration"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the constant variant of hydra.ext.csharp.syntax.StructMemberDeclaration
structMemberDeclarationConstant :: Typed.TypedTerm Syntax.ConstantDeclaration -> Typed.TypedTerm Syntax.StructMemberDeclaration
structMemberDeclarationConstant x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructMemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "constant"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the constructor variant of hydra.ext.csharp.syntax.StructMemberDeclaration
structMemberDeclarationConstructor :: Typed.TypedTerm Syntax.ConstructorDeclaration -> Typed.TypedTerm Syntax.StructMemberDeclaration
structMemberDeclarationConstructor x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructMemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "constructor"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the event variant of hydra.ext.csharp.syntax.StructMemberDeclaration
structMemberDeclarationEvent :: Typed.TypedTerm Syntax.EventDeclaration -> Typed.TypedTerm Syntax.StructMemberDeclaration
structMemberDeclarationEvent x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructMemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "event"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the field variant of hydra.ext.csharp.syntax.StructMemberDeclaration
structMemberDeclarationField :: Typed.TypedTerm Syntax.FieldDeclaration -> Typed.TypedTerm Syntax.StructMemberDeclaration
structMemberDeclarationField x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructMemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "field"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the fixedSizeBuffer variant of hydra.ext.csharp.syntax.StructMemberDeclaration
structMemberDeclarationFixedSizeBuffer :: Typed.TypedTerm Syntax.FixedSizeBufferDeclaration -> Typed.TypedTerm Syntax.StructMemberDeclaration
structMemberDeclarationFixedSizeBuffer x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructMemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "fixedSizeBuffer"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the indexer variant of hydra.ext.csharp.syntax.StructMemberDeclaration
structMemberDeclarationIndexer :: Typed.TypedTerm Syntax.IndexerDeclaration -> Typed.TypedTerm Syntax.StructMemberDeclaration
structMemberDeclarationIndexer x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructMemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "indexer"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the method variant of hydra.ext.csharp.syntax.StructMemberDeclaration
structMemberDeclarationMethod :: Typed.TypedTerm Syntax.MethodDeclaration -> Typed.TypedTerm Syntax.StructMemberDeclaration
structMemberDeclarationMethod x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructMemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "method"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the operator variant of hydra.ext.csharp.syntax.StructMemberDeclaration
structMemberDeclarationOperator :: Typed.TypedTerm Syntax.OperatorDeclaration -> Typed.TypedTerm Syntax.StructMemberDeclaration
structMemberDeclarationOperator x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructMemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "operator"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the property variant of hydra.ext.csharp.syntax.StructMemberDeclaration
structMemberDeclarationProperty :: Typed.TypedTerm Syntax.PropertyDeclaration -> Typed.TypedTerm Syntax.StructMemberDeclaration
structMemberDeclarationProperty x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructMemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "property"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the staticConstructor variant of hydra.ext.csharp.syntax.StructMemberDeclaration
structMemberDeclarationStaticConstructor :: Typed.TypedTerm Syntax.StaticConstructorDeclaration -> Typed.TypedTerm Syntax.StructMemberDeclaration
structMemberDeclarationStaticConstructor x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructMemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "staticConstructor"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.StructMemberDeclaration
structMemberDeclarationStructMemberDeclaration :: Typed.TypedName Syntax.StructMemberDeclaration
structMemberDeclarationStructMemberDeclaration =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StructMemberDeclaration")

-- | DSL injection for the type variant of hydra.ext.csharp.syntax.StructMemberDeclaration
structMemberDeclarationType :: Typed.TypedTerm Syntax.TypeDeclaration -> Typed.TypedTerm Syntax.StructMemberDeclaration
structMemberDeclarationType x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructMemberDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "type"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the internal variant of hydra.ext.csharp.syntax.StructModifier
structModifierInternal :: Typed.TypedTerm Syntax.StructModifier
structModifierInternal =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "internal"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the new variant of hydra.ext.csharp.syntax.StructModifier
structModifierNew :: Typed.TypedTerm Syntax.StructModifier
structModifierNew =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "new"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the private variant of hydra.ext.csharp.syntax.StructModifier
structModifierPrivate :: Typed.TypedTerm Syntax.StructModifier
structModifierPrivate =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "private"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the protected variant of hydra.ext.csharp.syntax.StructModifier
structModifierProtected :: Typed.TypedTerm Syntax.StructModifier
structModifierProtected =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "protected"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the public variant of hydra.ext.csharp.syntax.StructModifier
structModifierPublic :: Typed.TypedTerm Syntax.StructModifier
structModifierPublic =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "public"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the readonly variant of hydra.ext.csharp.syntax.StructModifier
structModifierReadonly :: Typed.TypedTerm Syntax.StructModifier
structModifierReadonly =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "readonly"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.csharp.syntax.StructModifier
structModifierStructModifier :: Typed.TypedName Syntax.StructModifier
structModifierStructModifier = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StructModifier")

-- | DSL injection for the unsafe variant of hydra.ext.csharp.syntax.StructModifier
structModifierUnsafe :: Typed.TypedTerm Syntax.StructModifier
structModifierUnsafe =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructModifier"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "unsafe"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the enum variant of hydra.ext.csharp.syntax.StructOrEnumType
structOrEnumTypeEnum :: Typed.TypedTerm Syntax.EnumType -> Typed.TypedTerm Syntax.StructOrEnumType
structOrEnumTypeEnum x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructOrEnumType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "enum"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the struct variant of hydra.ext.csharp.syntax.StructOrEnumType
structOrEnumTypeStruct :: Typed.TypedTerm Syntax.StructType -> Typed.TypedTerm Syntax.StructOrEnumType
structOrEnumTypeStruct x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructOrEnumType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "struct"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.StructOrEnumType
structOrEnumTypeStructOrEnumType :: Typed.TypedName Syntax.StructOrEnumType
structOrEnumTypeStructOrEnumType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StructOrEnumType")

-- | DSL injection for the simple variant of hydra.ext.csharp.syntax.StructType
structTypeSimple :: Typed.TypedTerm Syntax.SimpleType -> Typed.TypedTerm Syntax.StructType
structTypeSimple x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "simple"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.StructType
structTypeStructType :: Typed.TypedName Syntax.StructType
structTypeStructType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.StructType")

-- | DSL injection for the tuple variant of hydra.ext.csharp.syntax.StructType
structTypeTuple :: Typed.TypedTerm Syntax.TupleType -> Typed.TypedTerm Syntax.StructType
structTypeTuple x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "tuple"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the typeName variant of hydra.ext.csharp.syntax.StructType
structTypeTypeName :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.StructType
structTypeTypeName x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.StructType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "typeName"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.csharp.syntax.SwitchBranch
switchBranch :: Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.SwitchBranch
switchBranch pattern guard =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchBranch"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "pattern"),
          Model.fieldTerm = (Typed.unTypedTerm pattern)},
        Model.Field {
          Model.fieldName = (Model.Name "guard"),
          Model.fieldTerm = (Typed.unTypedTerm guard)}]}))

-- | DSL accessor for the guard field of hydra.ext.csharp.syntax.SwitchBranch
switchBranchGuard :: Typed.TypedTerm Syntax.SwitchBranch -> Typed.TypedTerm (Maybe Syntax.Expression)
switchBranchGuard x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchBranch"),
        Model.projectionFieldName = (Model.Name "guard")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the pattern field of hydra.ext.csharp.syntax.SwitchBranch
switchBranchPattern :: Typed.TypedTerm Syntax.SwitchBranch -> Typed.TypedTerm Syntax.Pattern
switchBranchPattern x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchBranch"),
        Model.projectionFieldName = (Model.Name "pattern")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.SwitchBranch
switchBranchSwitchBranch :: Typed.TypedName Syntax.SwitchBranch
switchBranchSwitchBranch = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.SwitchBranch")

-- | DSL updater for the guard field of hydra.ext.csharp.syntax.SwitchBranch
switchBranchWithGuard :: Typed.TypedTerm Syntax.SwitchBranch -> Typed.TypedTerm (Maybe Syntax.Expression) -> Typed.TypedTerm Syntax.SwitchBranch
switchBranchWithGuard original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchBranch"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "pattern"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchBranch"),
              Model.projectionFieldName = (Model.Name "pattern")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "guard"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the pattern field of hydra.ext.csharp.syntax.SwitchBranch
switchBranchWithPattern :: Typed.TypedTerm Syntax.SwitchBranch -> Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.SwitchBranch
switchBranchWithPattern original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchBranch"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "pattern"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "guard"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchBranch"),
              Model.projectionFieldName = (Model.Name "guard")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the branch variant of hydra.ext.csharp.syntax.SwitchLabel
switchLabelBranch :: Typed.TypedTerm Syntax.SwitchBranch -> Typed.TypedTerm Syntax.SwitchLabel
switchLabelBranch x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchLabel"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "branch"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the default variant of hydra.ext.csharp.syntax.SwitchLabel
switchLabelDefault :: Typed.TypedTerm Syntax.SwitchLabel
switchLabelDefault =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchLabel"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "default"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.csharp.syntax.SwitchLabel
switchLabelSwitchLabel :: Typed.TypedName Syntax.SwitchLabel
switchLabelSwitchLabel = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.SwitchLabel")

-- | DSL constructor for hydra.ext.csharp.syntax.SwitchSection
switchSection :: Typed.TypedTerm [Syntax.SwitchLabel] -> Typed.TypedTerm [Syntax.Statement] -> Typed.TypedTerm Syntax.SwitchSection
switchSection labels statements =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchSection"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "labels"),
          Model.fieldTerm = (Typed.unTypedTerm labels)},
        Model.Field {
          Model.fieldName = (Model.Name "statements"),
          Model.fieldTerm = (Typed.unTypedTerm statements)}]}))

-- | DSL accessor for the labels field of hydra.ext.csharp.syntax.SwitchSection
switchSectionLabels :: Typed.TypedTerm Syntax.SwitchSection -> Typed.TypedTerm [Syntax.SwitchLabel]
switchSectionLabels x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchSection"),
        Model.projectionFieldName = (Model.Name "labels")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the statements field of hydra.ext.csharp.syntax.SwitchSection
switchSectionStatements :: Typed.TypedTerm Syntax.SwitchSection -> Typed.TypedTerm [Syntax.Statement]
switchSectionStatements x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchSection"),
        Model.projectionFieldName = (Model.Name "statements")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.SwitchSection
switchSectionSwitchSection :: Typed.TypedName Syntax.SwitchSection
switchSectionSwitchSection = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.SwitchSection")

-- | DSL updater for the labels field of hydra.ext.csharp.syntax.SwitchSection
switchSectionWithLabels :: Typed.TypedTerm Syntax.SwitchSection -> Typed.TypedTerm [Syntax.SwitchLabel] -> Typed.TypedTerm Syntax.SwitchSection
switchSectionWithLabels original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchSection"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "labels"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "statements"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchSection"),
              Model.projectionFieldName = (Model.Name "statements")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the statements field of hydra.ext.csharp.syntax.SwitchSection
switchSectionWithStatements :: Typed.TypedTerm Syntax.SwitchSection -> Typed.TypedTerm [Syntax.Statement] -> Typed.TypedTerm Syntax.SwitchSection
switchSectionWithStatements original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchSection"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "labels"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchSection"),
              Model.projectionFieldName = (Model.Name "labels")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "statements"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.SwitchStatement
switchStatement :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm [Syntax.SwitchSection] -> Typed.TypedTerm Syntax.SwitchStatement
switchStatement expression branches =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm expression)},
        Model.Field {
          Model.fieldName = (Model.Name "branches"),
          Model.fieldTerm = (Typed.unTypedTerm branches)}]}))

-- | DSL accessor for the branches field of hydra.ext.csharp.syntax.SwitchStatement
switchStatementBranches :: Typed.TypedTerm Syntax.SwitchStatement -> Typed.TypedTerm [Syntax.SwitchSection]
switchStatementBranches x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchStatement"),
        Model.projectionFieldName = (Model.Name "branches")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.SwitchStatement
switchStatementExpression :: Typed.TypedTerm Syntax.SwitchStatement -> Typed.TypedTerm Syntax.Expression
switchStatementExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchStatement"),
        Model.projectionFieldName = (Model.Name "expression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.SwitchStatement
switchStatementSwitchStatement :: Typed.TypedName Syntax.SwitchStatement
switchStatementSwitchStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.SwitchStatement")

-- | DSL updater for the branches field of hydra.ext.csharp.syntax.SwitchStatement
switchStatementWithBranches :: Typed.TypedTerm Syntax.SwitchStatement -> Typed.TypedTerm [Syntax.SwitchSection] -> Typed.TypedTerm Syntax.SwitchStatement
switchStatementWithBranches original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchStatement"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "branches"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the expression field of hydra.ext.csharp.syntax.SwitchStatement
switchStatementWithExpression :: Typed.TypedTerm Syntax.SwitchStatement -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SwitchStatement
switchStatementWithExpression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "branches"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.SwitchStatement"),
              Model.projectionFieldName = (Model.Name "branches")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.TryStatement
tryStatement :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.CatchClauses -> Typed.TypedTerm (Maybe Syntax.Block) -> Typed.TypedTerm Syntax.TryStatement
tryStatement body catches finally =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TryStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)},
        Model.Field {
          Model.fieldName = (Model.Name "catches"),
          Model.fieldTerm = (Typed.unTypedTerm catches)},
        Model.Field {
          Model.fieldName = (Model.Name "finally"),
          Model.fieldTerm = (Typed.unTypedTerm finally)}]}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.TryStatement
tryStatementBody :: Typed.TypedTerm Syntax.TryStatement -> Typed.TypedTerm Syntax.Block
tryStatementBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TryStatement"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the catches field of hydra.ext.csharp.syntax.TryStatement
tryStatementCatches :: Typed.TypedTerm Syntax.TryStatement -> Typed.TypedTerm Syntax.CatchClauses
tryStatementCatches x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TryStatement"),
        Model.projectionFieldName = (Model.Name "catches")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the finally field of hydra.ext.csharp.syntax.TryStatement
tryStatementFinally :: Typed.TypedTerm Syntax.TryStatement -> Typed.TypedTerm (Maybe Syntax.Block)
tryStatementFinally x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TryStatement"),
        Model.projectionFieldName = (Model.Name "finally")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.TryStatement
tryStatementTryStatement :: Typed.TypedName Syntax.TryStatement
tryStatementTryStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.TryStatement")

-- | DSL updater for the body field of hydra.ext.csharp.syntax.TryStatement
tryStatementWithBody :: Typed.TypedTerm Syntax.TryStatement -> Typed.TypedTerm Syntax.Block -> Typed.TypedTerm Syntax.TryStatement
tryStatementWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TryStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "catches"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TryStatement"),
              Model.projectionFieldName = (Model.Name "catches")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "finally"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TryStatement"),
              Model.projectionFieldName = (Model.Name "finally")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the catches field of hydra.ext.csharp.syntax.TryStatement
tryStatementWithCatches :: Typed.TypedTerm Syntax.TryStatement -> Typed.TypedTerm Syntax.CatchClauses -> Typed.TypedTerm Syntax.TryStatement
tryStatementWithCatches original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TryStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TryStatement"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "catches"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "finally"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TryStatement"),
              Model.projectionFieldName = (Model.Name "finally")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the finally field of hydra.ext.csharp.syntax.TryStatement
tryStatementWithFinally :: Typed.TypedTerm Syntax.TryStatement -> Typed.TypedTerm (Maybe Syntax.Block) -> Typed.TypedTerm Syntax.TryStatement
tryStatementWithFinally original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TryStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TryStatement"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "catches"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TryStatement"),
              Model.projectionFieldName = (Model.Name "catches")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "finally"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.TupleElement
tupleElement :: Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.TupleElement
tupleElement name expression =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleElement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm expression)}]}))

-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.TupleElement
tupleElementExpression :: Typed.TypedTerm Syntax.TupleElement -> Typed.TypedTerm Syntax.Expression
tupleElementExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleElement"),
        Model.projectionFieldName = (Model.Name "expression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the name field of hydra.ext.csharp.syntax.TupleElement
tupleElementName :: Typed.TypedTerm Syntax.TupleElement -> Typed.TypedTerm (Maybe Syntax.Identifier)
tupleElementName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleElement"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.TupleElement
tupleElementTupleElement :: Typed.TypedName Syntax.TupleElement
tupleElementTupleElement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.TupleElement")

-- | DSL updater for the expression field of hydra.ext.csharp.syntax.TupleElement
tupleElementWithExpression :: Typed.TypedTerm Syntax.TupleElement -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.TupleElement
tupleElementWithExpression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleElement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleElement"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the name field of hydra.ext.csharp.syntax.TupleElement
tupleElementWithName :: Typed.TypedTerm Syntax.TupleElement -> Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.TupleElement
tupleElementWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleElement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleElement"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the deconstruction variant of hydra.ext.csharp.syntax.TupleExpression
tupleExpressionDeconstruction :: Typed.TypedTerm Syntax.DeconstructionTuple -> Typed.TypedTerm Syntax.TupleExpression
tupleExpressionDeconstruction x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "deconstruction"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the elements variant of hydra.ext.csharp.syntax.TupleExpression
tupleExpressionElements :: Typed.TypedTerm [Syntax.TupleElement] -> Typed.TypedTerm Syntax.TupleExpression
tupleExpressionElements x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "elements"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.TupleExpression
tupleExpressionTupleExpression :: Typed.TypedName Syntax.TupleExpression
tupleExpressionTupleExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.TupleExpression")

-- | DSL constructor for the hydra.ext.csharp.syntax.TupleType wrapper
tupleType :: Typed.TypedTerm [Syntax.TupleTypeElement] -> Typed.TypedTerm Syntax.TupleType
tupleType x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleType"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL constructor for hydra.ext.csharp.syntax.TupleTypeElement
tupleTypeElement :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.TupleTypeElement
tupleTypeElement type_ identifier =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleTypeElement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm identifier)}]}))

-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.TupleTypeElement
tupleTypeElementIdentifier :: Typed.TypedTerm Syntax.TupleTypeElement -> Typed.TypedTerm (Maybe Syntax.Identifier)
tupleTypeElementIdentifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleTypeElement"),
        Model.projectionFieldName = (Model.Name "identifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.TupleTypeElement
tupleTypeElementTupleTypeElement :: Typed.TypedName Syntax.TupleTypeElement
tupleTypeElementTupleTypeElement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.TupleTypeElement")

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.TupleTypeElement
tupleTypeElementType :: Typed.TypedTerm Syntax.TupleTypeElement -> Typed.TypedTerm Syntax.Type
tupleTypeElementType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleTypeElement"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.TupleTypeElement
tupleTypeElementWithIdentifier :: Typed.TypedTerm Syntax.TupleTypeElement -> Typed.TypedTerm (Maybe Syntax.Identifier) -> Typed.TypedTerm Syntax.TupleTypeElement
tupleTypeElementWithIdentifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleTypeElement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleTypeElement"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.TupleTypeElement
tupleTypeElementWithType :: Typed.TypedTerm Syntax.TupleTypeElement -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TupleTypeElement
tupleTypeElementWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleTypeElement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TupleTypeElement"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL name token for hydra.ext.csharp.syntax.TupleType
tupleTypeTupleType :: Typed.TypedName Syntax.TupleType
tupleTypeTupleType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.TupleType")

-- | DSL constructor for the hydra.ext.csharp.syntax.TypeArgumentList wrapper
typeArgumentList :: Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.TypeArgumentList
typeArgumentList x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeArgumentList"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.TypeArgumentList
typeArgumentListTypeArgumentList :: Typed.TypedName Syntax.TypeArgumentList
typeArgumentListTypeArgumentList = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.TypeArgumentList")

-- | DSL injection for the class variant of hydra.ext.csharp.syntax.TypeDeclaration
typeDeclarationClass :: Typed.TypedTerm Syntax.ClassDeclaration -> Typed.TypedTerm Syntax.TypeDeclaration
typeDeclarationClass x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "class"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the delegate variant of hydra.ext.csharp.syntax.TypeDeclaration
typeDeclarationDelegate :: Typed.TypedTerm Syntax.DelegateDeclaration -> Typed.TypedTerm Syntax.TypeDeclaration
typeDeclarationDelegate x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "delegate"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the enum variant of hydra.ext.csharp.syntax.TypeDeclaration
typeDeclarationEnum :: Typed.TypedTerm Syntax.EnumDeclaration -> Typed.TypedTerm Syntax.TypeDeclaration
typeDeclarationEnum x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "enum"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the interface variant of hydra.ext.csharp.syntax.TypeDeclaration
typeDeclarationInterface :: Typed.TypedTerm Syntax.InterfaceDeclaration -> Typed.TypedTerm Syntax.TypeDeclaration
typeDeclarationInterface x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "interface"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the struct variant of hydra.ext.csharp.syntax.TypeDeclaration
typeDeclarationStruct :: Typed.TypedTerm Syntax.StructDeclaration -> Typed.TypedTerm Syntax.TypeDeclaration
typeDeclarationStruct x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeDeclaration"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "struct"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.TypeDeclaration
typeDeclarationTypeDeclaration :: Typed.TypedName Syntax.TypeDeclaration
typeDeclarationTypeDeclaration = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.TypeDeclaration")

-- | DSL constructor for the hydra.ext.csharp.syntax.TypeName wrapper
typeName :: Typed.TypedTerm Syntax.NamespaceOrTypeName -> Typed.TypedTerm Syntax.TypeName
typeName x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeName"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.TypeName
typeNameTypeName :: Typed.TypedName Syntax.TypeName
typeNameTypeName = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.TypeName")

-- | DSL injection for the param variant of hydra.ext.csharp.syntax.Type
typeParam :: Typed.TypedTerm Syntax.TypeParameter -> Typed.TypedTerm Syntax.Type
typeParam x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Type"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "param"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for the hydra.ext.csharp.syntax.TypeParameter wrapper
typeParameter :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.TypeParameter
typeParameter x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameter"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL constructor for hydra.ext.csharp.syntax.TypeParameterConstraints
typeParameterConstraints :: Typed.TypedTerm (Maybe Syntax.PrimaryConstraint) -> Typed.TypedTerm (Maybe Syntax.SecondaryConstraints) -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.TypeParameterConstraints
typeParameterConstraints primary secondary constructor =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraints"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "primary"),
          Model.fieldTerm = (Typed.unTypedTerm primary)},
        Model.Field {
          Model.fieldName = (Model.Name "secondary"),
          Model.fieldTerm = (Typed.unTypedTerm secondary)},
        Model.Field {
          Model.fieldName = (Model.Name "constructor"),
          Model.fieldTerm = (Typed.unTypedTerm constructor)}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.TypeParameterConstraintsClause
typeParameterConstraintsClause :: Typed.TypedTerm Syntax.TypeParameter -> Typed.TypedTerm [Syntax.TypeParameterConstraints] -> Typed.TypedTerm Syntax.TypeParameterConstraintsClause
typeParameterConstraintsClause parameter constraints =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraintsClause"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "parameter"),
          Model.fieldTerm = (Typed.unTypedTerm parameter)},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Typed.unTypedTerm constraints)}]}))

-- | DSL accessor for the constraints field of hydra.ext.csharp.syntax.TypeParameterConstraintsClause
typeParameterConstraintsClauseConstraints :: Typed.TypedTerm Syntax.TypeParameterConstraintsClause -> Typed.TypedTerm [Syntax.TypeParameterConstraints]
typeParameterConstraintsClauseConstraints x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraintsClause"),
        Model.projectionFieldName = (Model.Name "constraints")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the parameter field of hydra.ext.csharp.syntax.TypeParameterConstraintsClause
typeParameterConstraintsClauseParameter :: Typed.TypedTerm Syntax.TypeParameterConstraintsClause -> Typed.TypedTerm Syntax.TypeParameter
typeParameterConstraintsClauseParameter x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraintsClause"),
        Model.projectionFieldName = (Model.Name "parameter")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.TypeParameterConstraintsClause
typeParameterConstraintsClauseTypeParameterConstraintsClause :: Typed.TypedName Syntax.TypeParameterConstraintsClause
typeParameterConstraintsClauseTypeParameterConstraintsClause =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraintsClause")

-- | DSL updater for the constraints field of hydra.ext.csharp.syntax.TypeParameterConstraintsClause
typeParameterConstraintsClauseWithConstraints :: Typed.TypedTerm Syntax.TypeParameterConstraintsClause -> Typed.TypedTerm [Syntax.TypeParameterConstraints] -> Typed.TypedTerm Syntax.TypeParameterConstraintsClause
typeParameterConstraintsClauseWithConstraints original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraintsClause"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "parameter"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraintsClause"),
              Model.projectionFieldName = (Model.Name "parameter")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the parameter field of hydra.ext.csharp.syntax.TypeParameterConstraintsClause
typeParameterConstraintsClauseWithParameter :: Typed.TypedTerm Syntax.TypeParameterConstraintsClause -> Typed.TypedTerm Syntax.TypeParameter -> Typed.TypedTerm Syntax.TypeParameterConstraintsClause
typeParameterConstraintsClauseWithParameter original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraintsClause"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "parameter"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraintsClause"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL accessor for the constructor field of hydra.ext.csharp.syntax.TypeParameterConstraints
typeParameterConstraintsConstructor :: Typed.TypedTerm Syntax.TypeParameterConstraints -> Typed.TypedTerm Bool
typeParameterConstraintsConstructor x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraints"),
        Model.projectionFieldName = (Model.Name "constructor")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the primary field of hydra.ext.csharp.syntax.TypeParameterConstraints
typeParameterConstraintsPrimary :: Typed.TypedTerm Syntax.TypeParameterConstraints -> Typed.TypedTerm (Maybe Syntax.PrimaryConstraint)
typeParameterConstraintsPrimary x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraints"),
        Model.projectionFieldName = (Model.Name "primary")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the secondary field of hydra.ext.csharp.syntax.TypeParameterConstraints
typeParameterConstraintsSecondary :: Typed.TypedTerm Syntax.TypeParameterConstraints -> Typed.TypedTerm (Maybe Syntax.SecondaryConstraints)
typeParameterConstraintsSecondary x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraints"),
        Model.projectionFieldName = (Model.Name "secondary")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.TypeParameterConstraints
typeParameterConstraintsTypeParameterConstraints :: Typed.TypedName Syntax.TypeParameterConstraints
typeParameterConstraintsTypeParameterConstraints =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraints")

-- | DSL updater for the constructor field of hydra.ext.csharp.syntax.TypeParameterConstraints
typeParameterConstraintsWithConstructor :: Typed.TypedTerm Syntax.TypeParameterConstraints -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.TypeParameterConstraints
typeParameterConstraintsWithConstructor original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraints"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "primary"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraints"),
              Model.projectionFieldName = (Model.Name "primary")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "secondary"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraints"),
              Model.projectionFieldName = (Model.Name "secondary")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constructor"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the primary field of hydra.ext.csharp.syntax.TypeParameterConstraints
typeParameterConstraintsWithPrimary :: Typed.TypedTerm Syntax.TypeParameterConstraints -> Typed.TypedTerm (Maybe Syntax.PrimaryConstraint) -> Typed.TypedTerm Syntax.TypeParameterConstraints
typeParameterConstraintsWithPrimary original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraints"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "primary"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "secondary"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraints"),
              Model.projectionFieldName = (Model.Name "secondary")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constructor"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraints"),
              Model.projectionFieldName = (Model.Name "constructor")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the secondary field of hydra.ext.csharp.syntax.TypeParameterConstraints
typeParameterConstraintsWithSecondary :: Typed.TypedTerm Syntax.TypeParameterConstraints -> Typed.TypedTerm (Maybe Syntax.SecondaryConstraints) -> Typed.TypedTerm Syntax.TypeParameterConstraints
typeParameterConstraintsWithSecondary original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraints"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "primary"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraints"),
              Model.projectionFieldName = (Model.Name "primary")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "secondary"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "constructor"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterConstraints"),
              Model.projectionFieldName = (Model.Name "constructor")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for the hydra.ext.csharp.syntax.TypeParameterList wrapper
typeParameterList :: Typed.TypedTerm [Syntax.TypeParameterPart] -> Typed.TypedTerm Syntax.TypeParameterList
typeParameterList x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterList"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.TypeParameterList
typeParameterListTypeParameterList :: Typed.TypedName Syntax.TypeParameterList
typeParameterListTypeParameterList = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.TypeParameterList")

-- | DSL constructor for hydra.ext.csharp.syntax.TypeParameterPart
typeParameterPart :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.TypeParameter -> Typed.TypedTerm Syntax.TypeParameterPart
typeParameterPart attributes name =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterPart"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)}]}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.TypeParameterPart
typeParameterPartAttributes :: Typed.TypedTerm Syntax.TypeParameterPart -> Typed.TypedTerm (Maybe Syntax.Attributes)
typeParameterPartAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterPart"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the name field of hydra.ext.csharp.syntax.TypeParameterPart
typeParameterPartName :: Typed.TypedTerm Syntax.TypeParameterPart -> Typed.TypedTerm Syntax.TypeParameter
typeParameterPartName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterPart"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.TypeParameterPart
typeParameterPartTypeParameterPart :: Typed.TypedName Syntax.TypeParameterPart
typeParameterPartTypeParameterPart = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.TypeParameterPart")

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.TypeParameterPart
typeParameterPartWithAttributes :: Typed.TypedTerm Syntax.TypeParameterPart -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.TypeParameterPart
typeParameterPartWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterPart"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterPart"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.csharp.syntax.TypeParameterPart
typeParameterPartWithName :: Typed.TypedTerm Syntax.TypeParameterPart -> Typed.TypedTerm Syntax.TypeParameter -> Typed.TypedTerm Syntax.TypeParameterPart
typeParameterPartWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterPart"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeParameterPart"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL name token for hydra.ext.csharp.syntax.TypeParameter
typeParameterTypeParameter :: Typed.TypedName Syntax.TypeParameter
typeParameterTypeParameter = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.TypeParameter")

-- | DSL injection for the pointer variant of hydra.ext.csharp.syntax.Type
typePointer :: Typed.TypedTerm Syntax.PointerType -> Typed.TypedTerm Syntax.Type
typePointer x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Type"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "pointer"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the reference variant of hydra.ext.csharp.syntax.Type
typeReference :: Typed.TypedTerm Syntax.ReferenceType -> Typed.TypedTerm Syntax.Type
typeReference x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Type"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "reference"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.Type
typeType :: Typed.TypedName Syntax.Type
typeType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.Type")

-- | DSL injection for the value variant of hydra.ext.csharp.syntax.Type
typeValue :: Typed.TypedTerm Syntax.ValueType -> Typed.TypedTerm Syntax.Type
typeValue x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.Type"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "value"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the type variant of hydra.ext.csharp.syntax.TypeofExpression
typeofExpressionType :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.TypeofExpression
typeofExpressionType x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeofExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "type"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.TypeofExpression
typeofExpressionTypeofExpression :: Typed.TypedName Syntax.TypeofExpression
typeofExpressionTypeofExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.TypeofExpression")

-- | DSL injection for the unboundTypeName variant of hydra.ext.csharp.syntax.TypeofExpression
typeofExpressionUnboundTypeName :: Typed.TypedTerm Syntax.UnboundTypeName -> Typed.TypedTerm Syntax.TypeofExpression
typeofExpressionUnboundTypeName x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeofExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "unboundTypeName"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the void variant of hydra.ext.csharp.syntax.TypeofExpression
typeofExpressionVoid :: Typed.TypedTerm Syntax.TypeofExpression
typeofExpressionVoid =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.TypeofExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "void"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.ArgumentList
unArgumentList :: Typed.TypedTerm Syntax.ArgumentList -> Typed.TypedTerm [Syntax.Argument]
unArgumentList x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.ArgumentList")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.ArrayInitializer
unArrayInitializer :: Typed.TypedTerm Syntax.ArrayInitializer -> Typed.TypedTerm [Syntax.VariableInitializer]
unArrayInitializer x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.ArrayInitializer")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.AttributeArgumentExpression
unAttributeArgumentExpression :: Typed.TypedTerm Syntax.AttributeArgumentExpression -> Typed.TypedTerm Syntax.NonAssignmentExpression
unAttributeArgumentExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.AttributeArgumentExpression")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.AttributeList
unAttributeList :: Typed.TypedTerm Syntax.AttributeList -> Typed.TypedTerm [Syntax.Attribute]
unAttributeList x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.AttributeList")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.AttributeName
unAttributeName :: Typed.TypedTerm Syntax.AttributeName -> Typed.TypedTerm Syntax.TypeName
unAttributeName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.AttributeName")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.Attributes
unAttributes :: Typed.TypedTerm Syntax.Attributes -> Typed.TypedTerm [Syntax.AttributeSection]
unAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.Attributes")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.Block
unBlock :: Typed.TypedTerm Syntax.Block -> Typed.TypedTerm [Syntax.Statement]
unBlock x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.Block")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.BooleanExpression
unBooleanExpression :: Typed.TypedTerm Syntax.BooleanExpression -> Typed.TypedTerm Syntax.Expression
unBooleanExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.BooleanExpression")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.ClassBody
unClassBody :: Typed.TypedTerm Syntax.ClassBody -> Typed.TypedTerm [Syntax.ClassMemberDeclaration]
unClassBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.ClassBody")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.ConstantExpression
unConstantExpression :: Typed.TypedTerm Syntax.ConstantExpression -> Typed.TypedTerm Syntax.Expression
unConstantExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.ConstantExpression")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.DeconstructionTuple
unDeconstructionTuple :: Typed.TypedTerm Syntax.DeconstructionTuple -> Typed.TypedTerm [Syntax.DeconstructionElement]
unDeconstructionTuple x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.DeconstructionTuple")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.DelegateType
unDelegateType :: Typed.TypedTerm Syntax.DelegateType -> Typed.TypedTerm Syntax.TypeName
unDelegateType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.DelegateType")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.Designation
unDesignation :: Typed.TypedTerm Syntax.Designation -> Typed.TypedTerm Syntax.Identifier
unDesignation x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.Designation")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.EnumBody
unEnumBody :: Typed.TypedTerm Syntax.EnumBody -> Typed.TypedTerm [Syntax.EnumMemberDeclaration]
unEnumBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.EnumBody")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.EnumType
unEnumType :: Typed.TypedTerm Syntax.EnumType -> Typed.TypedTerm Syntax.TypeName
unEnumType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.EnumType")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.ExpressionList
unExpressionList :: Typed.TypedTerm Syntax.ExpressionList -> Typed.TypedTerm [Syntax.Expression]
unExpressionList x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.ExpressionList")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.ExternAliasDirective
unExternAliasDirective :: Typed.TypedTerm Syntax.ExternAliasDirective -> Typed.TypedTerm Syntax.Identifier
unExternAliasDirective x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.ExternAliasDirective")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.Identifier
unIdentifier :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm String
unIdentifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.Identifier")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.InterfaceType
unInterfaceType :: Typed.TypedTerm Syntax.InterfaceType -> Typed.TypedTerm Syntax.TypeName
unInterfaceType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.InterfaceType")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.InterpolatedRegularStringExpression
unInterpolatedRegularStringExpression :: Typed.TypedTerm Syntax.InterpolatedRegularStringExpression -> Typed.TypedTerm String
unInterpolatedRegularStringExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.InterpolatedRegularStringExpression")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.InterpolatedVerbatimStringExpression
unInterpolatedVerbatimStringExpression :: Typed.TypedTerm Syntax.InterpolatedVerbatimStringExpression -> Typed.TypedTerm String
unInterpolatedVerbatimStringExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.InterpolatedVerbatimStringExpression")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.Keyword
unKeyword :: Typed.TypedTerm Syntax.Keyword -> Typed.TypedTerm String
unKeyword x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.Keyword")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.MemberDeclaratorList
unMemberDeclaratorList :: Typed.TypedTerm Syntax.MemberDeclaratorList -> Typed.TypedTerm [Syntax.MemberDeclarator]
unMemberDeclaratorList x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.MemberDeclaratorList")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.NamedArgumentList
unNamedArgumentList :: Typed.TypedTerm Syntax.NamedArgumentList -> Typed.TypedTerm [Syntax.NamedArgument]
unNamedArgumentList x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.NamedArgumentList")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.NamespaceName
unNamespaceName :: Typed.TypedTerm Syntax.NamespaceName -> Typed.TypedTerm Syntax.NamespaceOrTypeName
unNamespaceName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.NamespaceName")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.PositionalArgumentList
unPositionalArgumentList :: Typed.TypedTerm Syntax.PositionalArgumentList -> Typed.TypedTerm [Syntax.PositionalArgument]
unPositionalArgumentList x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.PositionalArgumentList")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.QualifiedIdentifier
unQualifiedIdentifier :: Typed.TypedTerm Syntax.QualifiedIdentifier -> Typed.TypedTerm [Syntax.Identifier]
unQualifiedIdentifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.QualifiedIdentifier")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.RankSpecifier
unRankSpecifier :: Typed.TypedTerm Syntax.RankSpecifier -> Typed.TypedTerm Int
unRankSpecifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.RankSpecifier")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.SecondaryConstraints
unSecondaryConstraints :: Typed.TypedTerm Syntax.SecondaryConstraints -> Typed.TypedTerm [Syntax.SecondaryConstraint]
unSecondaryConstraints x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.SecondaryConstraints")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.StatementExpressionList
unStatementExpressionList :: Typed.TypedTerm Syntax.StatementExpressionList -> Typed.TypedTerm [Syntax.StatementExpression]
unStatementExpressionList x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.StatementExpressionList")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.TupleType
unTupleType :: Typed.TypedTerm Syntax.TupleType -> Typed.TypedTerm [Syntax.TupleTypeElement]
unTupleType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.TupleType")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.TypeArgumentList
unTypeArgumentList :: Typed.TypedTerm Syntax.TypeArgumentList -> Typed.TypedTerm [Syntax.Type]
unTypeArgumentList x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.TypeArgumentList")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.TypeName
unTypeName :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.NamespaceOrTypeName
unTypeName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.TypeName")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.TypeParameter
unTypeParameter :: Typed.TypedTerm Syntax.TypeParameter -> Typed.TypedTerm Syntax.Identifier
unTypeParameter x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.TypeParameter")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.TypeParameterList
unTypeParameterList :: Typed.TypedTerm Syntax.TypeParameterList -> Typed.TypedTerm [Syntax.TypeParameterPart]
unTypeParameterList x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.TypeParameterList")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.UnboundTypeName
unUnboundTypeName :: Typed.TypedTerm Syntax.UnboundTypeName -> Typed.TypedTerm [Syntax.UnboundTypeNamePart]
unUnboundTypeName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.UnboundTypeName")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.VariableDeclarators
unVariableDeclarators :: Typed.TypedTerm Syntax.VariableDeclarators -> Typed.TypedTerm [Syntax.VariableDeclarator]
unVariableDeclarators x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.VariableDeclarators")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.VariableReference
unVariableReference :: Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Syntax.Expression
unVariableReference x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.VariableReference")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.csharp.syntax.VariantTypeParameters
unVariantTypeParameters :: Typed.TypedTerm Syntax.VariantTypeParameters -> Typed.TypedTerm [Syntax.VariantTypeParameter]
unVariantTypeParameters x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameters")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL injection for the addressOf variant of hydra.ext.csharp.syntax.UnaryExpression
unaryExpressionAddressOf :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.UnaryExpression
unaryExpressionAddressOf x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "addressOf"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the await variant of hydra.ext.csharp.syntax.UnaryExpression
unaryExpressionAwait :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.UnaryExpression
unaryExpressionAwait x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "await"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the bitwiseComplement variant of hydra.ext.csharp.syntax.UnaryExpression
unaryExpressionBitwiseComplement :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.UnaryExpression
unaryExpressionBitwiseComplement x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "bitwiseComplement"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the cast variant of hydra.ext.csharp.syntax.UnaryExpression
unaryExpressionCast :: Typed.TypedTerm Syntax.CastExpression -> Typed.TypedTerm Syntax.UnaryExpression
unaryExpressionCast x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "cast"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the minus variant of hydra.ext.csharp.syntax.UnaryExpression
unaryExpressionMinus :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.UnaryExpression
unaryExpressionMinus x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "minus"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the not variant of hydra.ext.csharp.syntax.UnaryExpression
unaryExpressionNot :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.UnaryExpression
unaryExpressionNot x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "not"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the plus variant of hydra.ext.csharp.syntax.UnaryExpression
unaryExpressionPlus :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.UnaryExpression
unaryExpressionPlus x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "plus"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the pointerIndirection variant of hydra.ext.csharp.syntax.UnaryExpression
unaryExpressionPointerIndirection :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.UnaryExpression
unaryExpressionPointerIndirection x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "pointerIndirection"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the preDecrement variant of hydra.ext.csharp.syntax.UnaryExpression
unaryExpressionPreDecrement :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.UnaryExpression
unaryExpressionPreDecrement x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "preDecrement"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the preIncrement variant of hydra.ext.csharp.syntax.UnaryExpression
unaryExpressionPreIncrement :: Typed.TypedTerm Syntax.UnaryExpression -> Typed.TypedTerm Syntax.UnaryExpression
unaryExpressionPreIncrement x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "preIncrement"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the primary variant of hydra.ext.csharp.syntax.UnaryExpression
unaryExpressionPrimary :: Typed.TypedTerm Syntax.PrimaryExpression -> Typed.TypedTerm Syntax.UnaryExpression
unaryExpressionPrimary x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryExpression"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "primary"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.UnaryExpression
unaryExpressionUnaryExpression :: Typed.TypedName Syntax.UnaryExpression
unaryExpressionUnaryExpression = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.UnaryExpression")

-- | DSL constructor for hydra.ext.csharp.syntax.UnaryOperatorDeclarator
unaryOperatorDeclarator :: Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.OverloadableUnaryOperator -> Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm Syntax.UnaryOperatorDeclarator
unaryOperatorDeclarator type_ operator parameter =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryOperatorDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Typed.unTypedTerm operator)},
        Model.Field {
          Model.fieldName = (Model.Name "parameter"),
          Model.fieldTerm = (Typed.unTypedTerm parameter)}]}))

-- | DSL accessor for the operator field of hydra.ext.csharp.syntax.UnaryOperatorDeclarator
unaryOperatorDeclaratorOperator :: Typed.TypedTerm Syntax.UnaryOperatorDeclarator -> Typed.TypedTerm Syntax.OverloadableUnaryOperator
unaryOperatorDeclaratorOperator x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryOperatorDeclarator"),
        Model.projectionFieldName = (Model.Name "operator")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the parameter field of hydra.ext.csharp.syntax.UnaryOperatorDeclarator
unaryOperatorDeclaratorParameter :: Typed.TypedTerm Syntax.UnaryOperatorDeclarator -> Typed.TypedTerm Syntax.FixedParameter
unaryOperatorDeclaratorParameter x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryOperatorDeclarator"),
        Model.projectionFieldName = (Model.Name "parameter")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.csharp.syntax.UnaryOperatorDeclarator
unaryOperatorDeclaratorType :: Typed.TypedTerm Syntax.UnaryOperatorDeclarator -> Typed.TypedTerm Syntax.Type
unaryOperatorDeclaratorType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryOperatorDeclarator"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.UnaryOperatorDeclarator
unaryOperatorDeclaratorUnaryOperatorDeclarator :: Typed.TypedName Syntax.UnaryOperatorDeclarator
unaryOperatorDeclaratorUnaryOperatorDeclarator =
    Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.UnaryOperatorDeclarator")

-- | DSL updater for the operator field of hydra.ext.csharp.syntax.UnaryOperatorDeclarator
unaryOperatorDeclaratorWithOperator :: Typed.TypedTerm Syntax.UnaryOperatorDeclarator -> Typed.TypedTerm Syntax.OverloadableUnaryOperator -> Typed.TypedTerm Syntax.UnaryOperatorDeclarator
unaryOperatorDeclaratorWithOperator original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryOperatorDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryOperatorDeclarator"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "parameter"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryOperatorDeclarator"),
              Model.projectionFieldName = (Model.Name "parameter")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the parameter field of hydra.ext.csharp.syntax.UnaryOperatorDeclarator
unaryOperatorDeclaratorWithParameter :: Typed.TypedTerm Syntax.UnaryOperatorDeclarator -> Typed.TypedTerm Syntax.FixedParameter -> Typed.TypedTerm Syntax.UnaryOperatorDeclarator
unaryOperatorDeclaratorWithParameter original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryOperatorDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryOperatorDeclarator"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryOperatorDeclarator"),
              Model.projectionFieldName = (Model.Name "operator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameter"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the type field of hydra.ext.csharp.syntax.UnaryOperatorDeclarator
unaryOperatorDeclaratorWithType :: Typed.TypedTerm Syntax.UnaryOperatorDeclarator -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.UnaryOperatorDeclarator
unaryOperatorDeclaratorWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryOperatorDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "operator"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryOperatorDeclarator"),
              Model.projectionFieldName = (Model.Name "operator")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameter"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnaryOperatorDeclarator"),
              Model.projectionFieldName = (Model.Name "parameter")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for the hydra.ext.csharp.syntax.UnboundTypeName wrapper
unboundTypeName :: Typed.TypedTerm [Syntax.UnboundTypeNamePart] -> Typed.TypedTerm Syntax.UnboundTypeName
unboundTypeName x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.UnboundTypeName"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL constructor for hydra.ext.csharp.syntax.UnboundTypeNamePart
unboundTypeNamePart :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Bool -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm Syntax.UnboundTypeNamePart
unboundTypeNamePart identifier aliased dimension =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.UnboundTypeNamePart"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm identifier)},
        Model.Field {
          Model.fieldName = (Model.Name "aliased"),
          Model.fieldTerm = (Typed.unTypedTerm aliased)},
        Model.Field {
          Model.fieldName = (Model.Name "dimension"),
          Model.fieldTerm = (Typed.unTypedTerm dimension)}]}))

-- | DSL accessor for the aliased field of hydra.ext.csharp.syntax.UnboundTypeNamePart
unboundTypeNamePartAliased :: Typed.TypedTerm Syntax.UnboundTypeNamePart -> Typed.TypedTerm Bool
unboundTypeNamePartAliased x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnboundTypeNamePart"),
        Model.projectionFieldName = (Model.Name "aliased")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the dimension field of hydra.ext.csharp.syntax.UnboundTypeNamePart
unboundTypeNamePartDimension :: Typed.TypedTerm Syntax.UnboundTypeNamePart -> Typed.TypedTerm (Maybe Int)
unboundTypeNamePartDimension x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnboundTypeNamePart"),
        Model.projectionFieldName = (Model.Name "dimension")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.UnboundTypeNamePart
unboundTypeNamePartIdentifier :: Typed.TypedTerm Syntax.UnboundTypeNamePart -> Typed.TypedTerm Syntax.Identifier
unboundTypeNamePartIdentifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnboundTypeNamePart"),
        Model.projectionFieldName = (Model.Name "identifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.UnboundTypeNamePart
unboundTypeNamePartUnboundTypeNamePart :: Typed.TypedName Syntax.UnboundTypeNamePart
unboundTypeNamePartUnboundTypeNamePart = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.UnboundTypeNamePart")

-- | DSL updater for the aliased field of hydra.ext.csharp.syntax.UnboundTypeNamePart
unboundTypeNamePartWithAliased :: Typed.TypedTerm Syntax.UnboundTypeNamePart -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.UnboundTypeNamePart
unboundTypeNamePartWithAliased original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.UnboundTypeNamePart"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnboundTypeNamePart"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "aliased"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "dimension"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnboundTypeNamePart"),
              Model.projectionFieldName = (Model.Name "dimension")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the dimension field of hydra.ext.csharp.syntax.UnboundTypeNamePart
unboundTypeNamePartWithDimension :: Typed.TypedTerm Syntax.UnboundTypeNamePart -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm Syntax.UnboundTypeNamePart
unboundTypeNamePartWithDimension original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.UnboundTypeNamePart"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnboundTypeNamePart"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "aliased"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnboundTypeNamePart"),
              Model.projectionFieldName = (Model.Name "aliased")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dimension"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.UnboundTypeNamePart
unboundTypeNamePartWithIdentifier :: Typed.TypedTerm Syntax.UnboundTypeNamePart -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.UnboundTypeNamePart
unboundTypeNamePartWithIdentifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.UnboundTypeNamePart"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "aliased"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnboundTypeNamePart"),
              Model.projectionFieldName = (Model.Name "aliased")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "dimension"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnboundTypeNamePart"),
              Model.projectionFieldName = (Model.Name "dimension")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL name token for hydra.ext.csharp.syntax.UnboundTypeName
unboundTypeNameUnboundTypeName :: Typed.TypedName Syntax.UnboundTypeName
unboundTypeNameUnboundTypeName = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.UnboundTypeName")

-- | DSL injection for the pointer variant of hydra.ext.csharp.syntax.UnmanagedType
unmanagedTypePointer :: Typed.TypedTerm Syntax.PointerType -> Typed.TypedTerm Syntax.UnmanagedType
unmanagedTypePointer x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnmanagedType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "pointer"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.UnmanagedType
unmanagedTypeUnmanagedType :: Typed.TypedName Syntax.UnmanagedType
unmanagedTypeUnmanagedType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.UnmanagedType")

-- | DSL injection for the value variant of hydra.ext.csharp.syntax.UnmanagedType
unmanagedTypeValue :: Typed.TypedTerm Syntax.ValueType -> Typed.TypedTerm Syntax.UnmanagedType
unmanagedTypeValue x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UnmanagedType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "value"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.csharp.syntax.UsingAliasDirective
usingAliasDirective :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.NamespaceOrTypeName -> Typed.TypedTerm Syntax.UsingAliasDirective
usingAliasDirective alias name =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingAliasDirective"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "alias"),
          Model.fieldTerm = (Typed.unTypedTerm alias)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)}]}))

-- | DSL accessor for the alias field of hydra.ext.csharp.syntax.UsingAliasDirective
usingAliasDirectiveAlias :: Typed.TypedTerm Syntax.UsingAliasDirective -> Typed.TypedTerm Syntax.Identifier
usingAliasDirectiveAlias x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingAliasDirective"),
        Model.projectionFieldName = (Model.Name "alias")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the name field of hydra.ext.csharp.syntax.UsingAliasDirective
usingAliasDirectiveName :: Typed.TypedTerm Syntax.UsingAliasDirective -> Typed.TypedTerm Syntax.NamespaceOrTypeName
usingAliasDirectiveName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingAliasDirective"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.UsingAliasDirective
usingAliasDirectiveUsingAliasDirective :: Typed.TypedName Syntax.UsingAliasDirective
usingAliasDirectiveUsingAliasDirective = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.UsingAliasDirective")

-- | DSL updater for the alias field of hydra.ext.csharp.syntax.UsingAliasDirective
usingAliasDirectiveWithAlias :: Typed.TypedTerm Syntax.UsingAliasDirective -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.UsingAliasDirective
usingAliasDirectiveWithAlias original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingAliasDirective"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "alias"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingAliasDirective"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.csharp.syntax.UsingAliasDirective
usingAliasDirectiveWithName :: Typed.TypedTerm Syntax.UsingAliasDirective -> Typed.TypedTerm Syntax.NamespaceOrTypeName -> Typed.TypedTerm Syntax.UsingAliasDirective
usingAliasDirectiveWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingAliasDirective"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "alias"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingAliasDirective"),
              Model.projectionFieldName = (Model.Name "alias")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the alias variant of hydra.ext.csharp.syntax.UsingDirective
usingDirectiveAlias :: Typed.TypedTerm Syntax.UsingAliasDirective -> Typed.TypedTerm Syntax.UsingDirective
usingDirectiveAlias x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingDirective"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "alias"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the namespace variant of hydra.ext.csharp.syntax.UsingDirective
usingDirectiveNamespace :: Typed.TypedTerm Syntax.NamespaceName -> Typed.TypedTerm Syntax.UsingDirective
usingDirectiveNamespace x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingDirective"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "namespace"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the static variant of hydra.ext.csharp.syntax.UsingDirective
usingDirectiveStatic :: Typed.TypedTerm Syntax.TypeName -> Typed.TypedTerm Syntax.UsingDirective
usingDirectiveStatic x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingDirective"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "static"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.UsingDirective
usingDirectiveUsingDirective :: Typed.TypedName Syntax.UsingDirective
usingDirectiveUsingDirective = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.UsingDirective")

-- | DSL constructor for hydra.ext.csharp.syntax.UsingStatement
usingStatement :: Typed.TypedTerm Syntax.ResourceAcquisition -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.UsingStatement
usingStatement acquisition body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "acquisition"),
          Model.fieldTerm = (Typed.unTypedTerm acquisition)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the acquisition field of hydra.ext.csharp.syntax.UsingStatement
usingStatementAcquisition :: Typed.TypedTerm Syntax.UsingStatement -> Typed.TypedTerm Syntax.ResourceAcquisition
usingStatementAcquisition x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingStatement"),
        Model.projectionFieldName = (Model.Name "acquisition")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.UsingStatement
usingStatementBody :: Typed.TypedTerm Syntax.UsingStatement -> Typed.TypedTerm Syntax.EmbeddedStatement
usingStatementBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingStatement"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.UsingStatement
usingStatementUsingStatement :: Typed.TypedName Syntax.UsingStatement
usingStatementUsingStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.UsingStatement")

-- | DSL updater for the acquisition field of hydra.ext.csharp.syntax.UsingStatement
usingStatementWithAcquisition :: Typed.TypedTerm Syntax.UsingStatement -> Typed.TypedTerm Syntax.ResourceAcquisition -> Typed.TypedTerm Syntax.UsingStatement
usingStatementWithAcquisition original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "acquisition"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingStatement"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the body field of hydra.ext.csharp.syntax.UsingStatement
usingStatementWithBody :: Typed.TypedTerm Syntax.UsingStatement -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.UsingStatement
usingStatementWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "acquisition"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.UsingStatement"),
              Model.projectionFieldName = (Model.Name "acquisition")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the nonNullable variant of hydra.ext.csharp.syntax.ValueType
valueTypeNonNullable :: Typed.TypedTerm Syntax.StructOrEnumType -> Typed.TypedTerm Syntax.ValueType
valueTypeNonNullable x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ValueType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "nonNullable"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the nullable variant of hydra.ext.csharp.syntax.ValueType
valueTypeNullable :: Typed.TypedTerm Syntax.StructOrEnumType -> Typed.TypedTerm Syntax.ValueType
valueTypeNullable x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.ValueType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "nullable"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.ValueType
valueTypeValueType :: Typed.TypedName Syntax.ValueType
valueTypeValueType = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.ValueType")

-- | DSL constructor for hydra.ext.csharp.syntax.VariableDeclarator
variableDeclarator :: Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm (Maybe Syntax.VariableInitializer) -> Typed.TypedTerm Syntax.VariableDeclarator
variableDeclarator identifier initializer =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.VariableDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm identifier)},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Typed.unTypedTerm initializer)}]}))

-- | DSL accessor for the identifier field of hydra.ext.csharp.syntax.VariableDeclarator
variableDeclaratorIdentifier :: Typed.TypedTerm Syntax.VariableDeclarator -> Typed.TypedTerm Syntax.Identifier
variableDeclaratorIdentifier x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VariableDeclarator"),
        Model.projectionFieldName = (Model.Name "identifier")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the initializer field of hydra.ext.csharp.syntax.VariableDeclarator
variableDeclaratorInitializer :: Typed.TypedTerm Syntax.VariableDeclarator -> Typed.TypedTerm (Maybe Syntax.VariableInitializer)
variableDeclaratorInitializer x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VariableDeclarator"),
        Model.projectionFieldName = (Model.Name "initializer")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.VariableDeclarator
variableDeclaratorVariableDeclarator :: Typed.TypedName Syntax.VariableDeclarator
variableDeclaratorVariableDeclarator = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.VariableDeclarator")

-- | DSL updater for the identifier field of hydra.ext.csharp.syntax.VariableDeclarator
variableDeclaratorWithIdentifier :: Typed.TypedTerm Syntax.VariableDeclarator -> Typed.TypedTerm Syntax.Identifier -> Typed.TypedTerm Syntax.VariableDeclarator
variableDeclaratorWithIdentifier original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.VariableDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VariableDeclarator"),
              Model.projectionFieldName = (Model.Name "initializer")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the initializer field of hydra.ext.csharp.syntax.VariableDeclarator
variableDeclaratorWithInitializer :: Typed.TypedTerm Syntax.VariableDeclarator -> Typed.TypedTerm (Maybe Syntax.VariableInitializer) -> Typed.TypedTerm Syntax.VariableDeclarator
variableDeclaratorWithInitializer original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.VariableDeclarator"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "identifier"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VariableDeclarator"),
              Model.projectionFieldName = (Model.Name "identifier")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "initializer"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for the hydra.ext.csharp.syntax.VariableDeclarators wrapper
variableDeclarators :: Typed.TypedTerm [Syntax.VariableDeclarator] -> Typed.TypedTerm Syntax.VariableDeclarators
variableDeclarators x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.VariableDeclarators"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.VariableDeclarators
variableDeclaratorsVariableDeclarators :: Typed.TypedName Syntax.VariableDeclarators
variableDeclaratorsVariableDeclarators = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.VariableDeclarators")

-- | DSL injection for the array variant of hydra.ext.csharp.syntax.VariableInitializer
variableInitializerArray :: Typed.TypedTerm Syntax.ArrayInitializer -> Typed.TypedTerm Syntax.VariableInitializer
variableInitializerArray x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VariableInitializer"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "array"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the expression variant of hydra.ext.csharp.syntax.VariableInitializer
variableInitializerExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.VariableInitializer
variableInitializerExpression x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VariableInitializer"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "expression"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.VariableInitializer
variableInitializerVariableInitializer :: Typed.TypedName Syntax.VariableInitializer
variableInitializerVariableInitializer = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.VariableInitializer")

-- | DSL constructor for the hydra.ext.csharp.syntax.VariableReference wrapper
variableReference :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.VariableReference
variableReference x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.VariableReference"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.VariableReference
variableReferenceVariableReference :: Typed.TypedName Syntax.VariableReference
variableReferenceVariableReference = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.VariableReference")

-- | DSL injection for the in variant of hydra.ext.csharp.syntax.VarianceAnnotation
varianceAnnotationIn :: Typed.TypedTerm Syntax.VarianceAnnotation
varianceAnnotationIn =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VarianceAnnotation"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "in"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the out variant of hydra.ext.csharp.syntax.VarianceAnnotation
varianceAnnotationOut :: Typed.TypedTerm Syntax.VarianceAnnotation
varianceAnnotationOut =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VarianceAnnotation"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "out"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.csharp.syntax.VarianceAnnotation
varianceAnnotationVarianceAnnotation :: Typed.TypedName Syntax.VarianceAnnotation
varianceAnnotationVarianceAnnotation = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.VarianceAnnotation")

-- | DSL constructor for hydra.ext.csharp.syntax.VariantTypeParameter
variantTypeParameter :: Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm (Maybe Syntax.VarianceAnnotation) -> Typed.TypedTerm Syntax.TypeParameter -> Typed.TypedTerm Syntax.VariantTypeParameter
variantTypeParameter attributes variance parameter =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameter"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm attributes)},
        Model.Field {
          Model.fieldName = (Model.Name "variance"),
          Model.fieldTerm = (Typed.unTypedTerm variance)},
        Model.Field {
          Model.fieldName = (Model.Name "parameter"),
          Model.fieldTerm = (Typed.unTypedTerm parameter)}]}))

-- | DSL accessor for the attributes field of hydra.ext.csharp.syntax.VariantTypeParameter
variantTypeParameterAttributes :: Typed.TypedTerm Syntax.VariantTypeParameter -> Typed.TypedTerm (Maybe Syntax.Attributes)
variantTypeParameterAttributes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameter"),
        Model.projectionFieldName = (Model.Name "attributes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the parameter field of hydra.ext.csharp.syntax.VariantTypeParameter
variantTypeParameterParameter :: Typed.TypedTerm Syntax.VariantTypeParameter -> Typed.TypedTerm Syntax.TypeParameter
variantTypeParameterParameter x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameter"),
        Model.projectionFieldName = (Model.Name "parameter")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the variance field of hydra.ext.csharp.syntax.VariantTypeParameter
variantTypeParameterVariance :: Typed.TypedTerm Syntax.VariantTypeParameter -> Typed.TypedTerm (Maybe Syntax.VarianceAnnotation)
variantTypeParameterVariance x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameter"),
        Model.projectionFieldName = (Model.Name "variance")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.VariantTypeParameter
variantTypeParameterVariantTypeParameter :: Typed.TypedName Syntax.VariantTypeParameter
variantTypeParameterVariantTypeParameter = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameter")

-- | DSL updater for the attributes field of hydra.ext.csharp.syntax.VariantTypeParameter
variantTypeParameterWithAttributes :: Typed.TypedTerm Syntax.VariantTypeParameter -> Typed.TypedTerm (Maybe Syntax.Attributes) -> Typed.TypedTerm Syntax.VariantTypeParameter
variantTypeParameterWithAttributes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameter"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "variance"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameter"),
              Model.projectionFieldName = (Model.Name "variance")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameter"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameter"),
              Model.projectionFieldName = (Model.Name "parameter")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the parameter field of hydra.ext.csharp.syntax.VariantTypeParameter
variantTypeParameterWithParameter :: Typed.TypedTerm Syntax.VariantTypeParameter -> Typed.TypedTerm Syntax.TypeParameter -> Typed.TypedTerm Syntax.VariantTypeParameter
variantTypeParameterWithParameter original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameter"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameter"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "variance"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameter"),
              Model.projectionFieldName = (Model.Name "variance")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "parameter"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the variance field of hydra.ext.csharp.syntax.VariantTypeParameter
variantTypeParameterWithVariance :: Typed.TypedTerm Syntax.VariantTypeParameter -> Typed.TypedTerm (Maybe Syntax.VarianceAnnotation) -> Typed.TypedTerm Syntax.VariantTypeParameter
variantTypeParameterWithVariance original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameter"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "attributes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameter"),
              Model.projectionFieldName = (Model.Name "attributes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "variance"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "parameter"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameter"),
              Model.projectionFieldName = (Model.Name "parameter")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for the hydra.ext.csharp.syntax.VariantTypeParameters wrapper
variantTypeParameters :: Typed.TypedTerm [Syntax.VariantTypeParameter] -> Typed.TypedTerm Syntax.VariantTypeParameters
variantTypeParameters x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameters"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.VariantTypeParameters
variantTypeParametersVariantTypeParameters :: Typed.TypedName Syntax.VariantTypeParameters
variantTypeParametersVariantTypeParameters = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.VariantTypeParameters")

-- | DSL constructor for hydra.ext.csharp.syntax.VerbatimInterpolation
verbatimInterpolation :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm (Maybe Syntax.ConstantExpression) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.VerbatimInterpolation
verbatimInterpolation expression width format =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.VerbatimInterpolation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm expression)},
        Model.Field {
          Model.fieldName = (Model.Name "width"),
          Model.fieldTerm = (Typed.unTypedTerm width)},
        Model.Field {
          Model.fieldName = (Model.Name "format"),
          Model.fieldTerm = (Typed.unTypedTerm format)}]}))

-- | DSL accessor for the expression field of hydra.ext.csharp.syntax.VerbatimInterpolation
verbatimInterpolationExpression :: Typed.TypedTerm Syntax.VerbatimInterpolation -> Typed.TypedTerm Syntax.Expression
verbatimInterpolationExpression x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VerbatimInterpolation"),
        Model.projectionFieldName = (Model.Name "expression")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the format field of hydra.ext.csharp.syntax.VerbatimInterpolation
verbatimInterpolationFormat :: Typed.TypedTerm Syntax.VerbatimInterpolation -> Typed.TypedTerm (Maybe String)
verbatimInterpolationFormat x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VerbatimInterpolation"),
        Model.projectionFieldName = (Model.Name "format")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.VerbatimInterpolation
verbatimInterpolationVerbatimInterpolation :: Typed.TypedName Syntax.VerbatimInterpolation
verbatimInterpolationVerbatimInterpolation = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.VerbatimInterpolation")

-- | DSL accessor for the width field of hydra.ext.csharp.syntax.VerbatimInterpolation
verbatimInterpolationWidth :: Typed.TypedTerm Syntax.VerbatimInterpolation -> Typed.TypedTerm (Maybe Syntax.ConstantExpression)
verbatimInterpolationWidth x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VerbatimInterpolation"),
        Model.projectionFieldName = (Model.Name "width")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the expression field of hydra.ext.csharp.syntax.VerbatimInterpolation
verbatimInterpolationWithExpression :: Typed.TypedTerm Syntax.VerbatimInterpolation -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.VerbatimInterpolation
verbatimInterpolationWithExpression original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.VerbatimInterpolation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "width"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VerbatimInterpolation"),
              Model.projectionFieldName = (Model.Name "width")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "format"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VerbatimInterpolation"),
              Model.projectionFieldName = (Model.Name "format")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the format field of hydra.ext.csharp.syntax.VerbatimInterpolation
verbatimInterpolationWithFormat :: Typed.TypedTerm Syntax.VerbatimInterpolation -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.VerbatimInterpolation
verbatimInterpolationWithFormat original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.VerbatimInterpolation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VerbatimInterpolation"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "width"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VerbatimInterpolation"),
              Model.projectionFieldName = (Model.Name "width")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "format"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the width field of hydra.ext.csharp.syntax.VerbatimInterpolation
verbatimInterpolationWithWidth :: Typed.TypedTerm Syntax.VerbatimInterpolation -> Typed.TypedTerm (Maybe Syntax.ConstantExpression) -> Typed.TypedTerm Syntax.VerbatimInterpolation
verbatimInterpolationWithWidth original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.VerbatimInterpolation"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "expression"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VerbatimInterpolation"),
              Model.projectionFieldName = (Model.Name "expression")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "width"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "format"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.VerbatimInterpolation"),
              Model.projectionFieldName = (Model.Name "format")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.csharp.syntax.WhileStatement
whileStatement :: Typed.TypedTerm Syntax.BooleanExpression -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.WhileStatement
whileStatement condition body =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.WhileStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Typed.unTypedTerm condition)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm body)}]}))

-- | DSL accessor for the body field of hydra.ext.csharp.syntax.WhileStatement
whileStatementBody :: Typed.TypedTerm Syntax.WhileStatement -> Typed.TypedTerm Syntax.EmbeddedStatement
whileStatementBody x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.WhileStatement"),
        Model.projectionFieldName = (Model.Name "body")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the condition field of hydra.ext.csharp.syntax.WhileStatement
whileStatementCondition :: Typed.TypedTerm Syntax.WhileStatement -> Typed.TypedTerm Syntax.BooleanExpression
whileStatementCondition x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.WhileStatement"),
        Model.projectionFieldName = (Model.Name "condition")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.csharp.syntax.WhileStatement
whileStatementWhileStatement :: Typed.TypedName Syntax.WhileStatement
whileStatementWhileStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.WhileStatement")

-- | DSL updater for the body field of hydra.ext.csharp.syntax.WhileStatement
whileStatementWithBody :: Typed.TypedTerm Syntax.WhileStatement -> Typed.TypedTerm Syntax.EmbeddedStatement -> Typed.TypedTerm Syntax.WhileStatement
whileStatementWithBody original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.WhileStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.WhileStatement"),
              Model.projectionFieldName = (Model.Name "condition")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the condition field of hydra.ext.csharp.syntax.WhileStatement
whileStatementWithCondition :: Typed.TypedTerm Syntax.WhileStatement -> Typed.TypedTerm Syntax.BooleanExpression -> Typed.TypedTerm Syntax.WhileStatement
whileStatementWithCondition original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.csharp.syntax.WhileStatement"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "condition"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "body"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.csharp.syntax.WhileStatement"),
              Model.projectionFieldName = (Model.Name "body")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the break variant of hydra.ext.csharp.syntax.YieldStatement
yieldStatementBreak :: Typed.TypedTerm Syntax.YieldStatement
yieldStatementBreak =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.YieldStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "break"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the return variant of hydra.ext.csharp.syntax.YieldStatement
yieldStatementReturn :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.YieldStatement
yieldStatementReturn x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.csharp.syntax.YieldStatement"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "return"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.csharp.syntax.YieldStatement
yieldStatementYieldStatement :: Typed.TypedName Syntax.YieldStatement
yieldStatementYieldStatement = Typed.TypedName (Model.Name "hydra.ext.csharp.syntax.YieldStatement")