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

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

-- | DSL functions for hydra.csharp.syntax

module Hydra.Dsl.Csharp.Syntax where

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

accessorBodyBlock :: Phantoms.TTerm Syntax.Block -> Phantoms.TTerm Syntax.AccessorBody
accessorBodyBlock x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "block"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

accessorBodyEmpty :: Phantoms.TTerm Syntax.AccessorBody
accessorBodyEmpty =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "empty"),
        Core.fieldTerm = Core.TermUnit}}))

accessorBodyExpression :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.AccessorBody
accessorBodyExpression x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "expression"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

accessorDeclaration :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm (Maybe Syntax.AccessorModifier) -> Phantoms.TTerm Syntax.AccessorBody -> Phantoms.TTerm Syntax.AccessorDeclaration
accessorDeclaration attributes modifier body =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.AccessorDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "modifier"),
          Core.fieldTerm = (Phantoms.unTTerm modifier)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)}]}))

accessorDeclarationAttributes :: Phantoms.TTerm Syntax.AccessorDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes)
accessorDeclarationAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorDeclaration"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

accessorDeclarationBody :: Phantoms.TTerm Syntax.AccessorDeclaration -> Phantoms.TTerm Syntax.AccessorBody
accessorDeclarationBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorDeclaration"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

accessorDeclarationModifier :: Phantoms.TTerm Syntax.AccessorDeclaration -> Phantoms.TTerm (Maybe Syntax.AccessorModifier)
accessorDeclarationModifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorDeclaration"),
        Core.projectionField = (Core.Name "modifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

accessorDeclarationWithAttributes :: Phantoms.TTerm Syntax.AccessorDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.AccessorDeclaration
accessorDeclarationWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.AccessorDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "modifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorDeclaration"),
              Core.projectionField = (Core.Name "modifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

accessorDeclarationWithBody :: Phantoms.TTerm Syntax.AccessorDeclaration -> Phantoms.TTerm Syntax.AccessorBody -> Phantoms.TTerm Syntax.AccessorDeclaration
accessorDeclarationWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.AccessorDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorDeclaration"),
              Core.projectionField = (Core.Name "modifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

accessorDeclarationWithModifier :: Phantoms.TTerm Syntax.AccessorDeclaration -> Phantoms.TTerm (Maybe Syntax.AccessorModifier) -> Phantoms.TTerm Syntax.AccessorDeclaration
accessorDeclarationWithModifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.AccessorDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

accessorDeclarationsGet :: Phantoms.TTerm (Maybe Syntax.AccessorDeclaration) -> Phantoms.TTerm Syntax.AccessorDeclarations
accessorDeclarationsGet x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorDeclarations"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "get"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

accessorDeclarationsSet :: Phantoms.TTerm (Maybe Syntax.AccessorDeclaration) -> Phantoms.TTerm Syntax.AccessorDeclarations
accessorDeclarationsSet x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorDeclarations"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "set"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

accessorModifierInternal :: Phantoms.TTerm Syntax.AccessorModifier
accessorModifierInternal =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "internal"),
        Core.fieldTerm = Core.TermUnit}}))

accessorModifierInternalProtected :: Phantoms.TTerm Syntax.AccessorModifier
accessorModifierInternalProtected =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "internalProtected"),
        Core.fieldTerm = Core.TermUnit}}))

accessorModifierPrivate :: Phantoms.TTerm Syntax.AccessorModifier
accessorModifierPrivate =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "private"),
        Core.fieldTerm = Core.TermUnit}}))

accessorModifierPrivateProtected :: Phantoms.TTerm Syntax.AccessorModifier
accessorModifierPrivateProtected =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "privateProtected"),
        Core.fieldTerm = Core.TermUnit}}))

accessorModifierProtected :: Phantoms.TTerm Syntax.AccessorModifier
accessorModifierProtected =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "protected"),
        Core.fieldTerm = Core.TermUnit}}))

accessorModifierProtectedInternal :: Phantoms.TTerm Syntax.AccessorModifier
accessorModifierProtectedInternal =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "protectedInternal"),
        Core.fieldTerm = Core.TermUnit}}))

accessorModifierProtectedPrivate :: Phantoms.TTerm Syntax.AccessorModifier
accessorModifierProtectedPrivate =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "protectedPrivate"),
        Core.fieldTerm = Core.TermUnit}}))

accessorsEventDeclaration :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm [Syntax.EventModifier] -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.MemberName -> Phantoms.TTerm Syntax.EventAccessorDeclarations -> Phantoms.TTerm Syntax.AccessorsEventDeclaration
accessorsEventDeclaration attributes modifiers type_ name accessors =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm modifiers)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm name)},
        Core.Field {
          Core.fieldName = (Core.Name "accessors"),
          Core.fieldTerm = (Phantoms.unTTerm accessors)}]}))

accessorsEventDeclarationAccessors :: Phantoms.TTerm Syntax.AccessorsEventDeclaration -> Phantoms.TTerm Syntax.EventAccessorDeclarations
accessorsEventDeclarationAccessors x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration"),
        Core.projectionField = (Core.Name "accessors")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

accessorsEventDeclarationAttributes :: Phantoms.TTerm Syntax.AccessorsEventDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes)
accessorsEventDeclarationAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

accessorsEventDeclarationModifiers :: Phantoms.TTerm Syntax.AccessorsEventDeclaration -> Phantoms.TTerm [Syntax.EventModifier]
accessorsEventDeclarationModifiers x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration"),
        Core.projectionField = (Core.Name "modifiers")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

accessorsEventDeclarationName :: Phantoms.TTerm Syntax.AccessorsEventDeclaration -> Phantoms.TTerm Syntax.MemberName
accessorsEventDeclarationName x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration"),
        Core.projectionField = (Core.Name "name")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

accessorsEventDeclarationType :: Phantoms.TTerm Syntax.AccessorsEventDeclaration -> Phantoms.TTerm Syntax.Type
accessorsEventDeclarationType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

accessorsEventDeclarationWithAccessors :: Phantoms.TTerm Syntax.AccessorsEventDeclaration -> Phantoms.TTerm Syntax.EventAccessorDeclarations -> Phantoms.TTerm Syntax.AccessorsEventDeclaration
accessorsEventDeclarationWithAccessors original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "accessors"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

accessorsEventDeclarationWithAttributes :: Phantoms.TTerm Syntax.AccessorsEventDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.AccessorsEventDeclaration
accessorsEventDeclarationWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "accessors"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration"),
              Core.projectionField = (Core.Name "accessors")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

accessorsEventDeclarationWithModifiers :: Phantoms.TTerm Syntax.AccessorsEventDeclaration -> Phantoms.TTerm [Syntax.EventModifier] -> Phantoms.TTerm Syntax.AccessorsEventDeclaration
accessorsEventDeclarationWithModifiers original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "accessors"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration"),
              Core.projectionField = (Core.Name "accessors")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

accessorsEventDeclarationWithName :: Phantoms.TTerm Syntax.AccessorsEventDeclaration -> Phantoms.TTerm Syntax.MemberName -> Phantoms.TTerm Syntax.AccessorsEventDeclaration
accessorsEventDeclarationWithName original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "accessors"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration"),
              Core.projectionField = (Core.Name "accessors")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

accessorsEventDeclarationWithType :: Phantoms.TTerm Syntax.AccessorsEventDeclaration -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.AccessorsEventDeclaration
accessorsEventDeclarationWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "accessors"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AccessorsEventDeclaration"),
              Core.projectionField = (Core.Name "accessors")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

addRemoveAccessorDeclaration :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.Block -> Phantoms.TTerm Syntax.AddRemoveAccessorDeclaration
addRemoveAccessorDeclaration attributes body =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.AddRemoveAccessorDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)}]}))

addRemoveAccessorDeclarationAttributes :: Phantoms.TTerm Syntax.AddRemoveAccessorDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes)
addRemoveAccessorDeclarationAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AddRemoveAccessorDeclaration"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

addRemoveAccessorDeclarationBody :: Phantoms.TTerm Syntax.AddRemoveAccessorDeclaration -> Phantoms.TTerm Syntax.Block
addRemoveAccessorDeclarationBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AddRemoveAccessorDeclaration"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

addRemoveAccessorDeclarationWithAttributes :: Phantoms.TTerm Syntax.AddRemoveAccessorDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.AddRemoveAccessorDeclaration
addRemoveAccessorDeclarationWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.AddRemoveAccessorDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AddRemoveAccessorDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

addRemoveAccessorDeclarationWithBody :: Phantoms.TTerm Syntax.AddRemoveAccessorDeclaration -> Phantoms.TTerm Syntax.Block -> Phantoms.TTerm Syntax.AddRemoveAccessorDeclaration
addRemoveAccessorDeclarationWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.AddRemoveAccessorDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AddRemoveAccessorDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

additiveExpressionBinary :: Phantoms.TTerm Syntax.BinaryAdditiveExpression -> Phantoms.TTerm Syntax.AdditiveExpression
additiveExpressionBinary x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AdditiveExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "binary"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

additiveExpressionSimple :: Phantoms.TTerm Syntax.MultiplicativeExpression -> Phantoms.TTerm Syntax.AdditiveExpression
additiveExpressionSimple x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AdditiveExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "simple"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

additiveOperatorMinus :: Phantoms.TTerm Syntax.AdditiveOperator
additiveOperatorMinus =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AdditiveOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "minus"),
        Core.fieldTerm = Core.TermUnit}}))

additiveOperatorPlus :: Phantoms.TTerm Syntax.AdditiveOperator
additiveOperatorPlus =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AdditiveOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "plus"),
        Core.fieldTerm = Core.TermUnit}}))

andExpressionBinary :: Phantoms.TTerm Syntax.BinaryAndExpression -> Phantoms.TTerm Syntax.AndExpression
andExpressionBinary x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AndExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "binary"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

andExpressionSimple :: Phantoms.TTerm Syntax.EqualityExpression -> Phantoms.TTerm Syntax.AndExpression
andExpressionSimple x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AndExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "simple"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

anonymousFunctionBodyBlock :: Phantoms.TTerm Syntax.Block -> Phantoms.TTerm Syntax.AnonymousFunctionBody
anonymousFunctionBodyBlock x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AnonymousFunctionBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "block"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

anonymousFunctionBodyExpression :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.AnonymousFunctionBody
anonymousFunctionBodyExpression x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AnonymousFunctionBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "expression"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

anonymousFunctionBodyNullConditionalInvocation :: Phantoms.TTerm Syntax.NullConditionalInvocationExpression -> Phantoms.TTerm Syntax.AnonymousFunctionBody
anonymousFunctionBodyNullConditionalInvocation x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AnonymousFunctionBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "nullConditionalInvocation"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

anonymousFunctionBodyRef :: Phantoms.TTerm Syntax.VariableReference -> Phantoms.TTerm Syntax.AnonymousFunctionBody
anonymousFunctionBodyRef x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AnonymousFunctionBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "ref"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

anonymousFunctionParameterModifierIn :: Phantoms.TTerm Syntax.AnonymousFunctionParameterModifier
anonymousFunctionParameterModifierIn =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AnonymousFunctionParameterModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "in"),
        Core.fieldTerm = Core.TermUnit}}))

anonymousFunctionParameterModifierOut :: Phantoms.TTerm Syntax.AnonymousFunctionParameterModifier
anonymousFunctionParameterModifierOut =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AnonymousFunctionParameterModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "out"),
        Core.fieldTerm = Core.TermUnit}}))

anonymousFunctionParameterModifierRef :: Phantoms.TTerm Syntax.AnonymousFunctionParameterModifier
anonymousFunctionParameterModifierRef =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AnonymousFunctionParameterModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "ref"),
        Core.fieldTerm = Core.TermUnit}}))

anonymousFunctionSignatureExplicit :: Phantoms.TTerm [Syntax.ExplicitAnonymousFunctionParameter] -> Phantoms.TTerm Syntax.AnonymousFunctionSignature
anonymousFunctionSignatureExplicit x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AnonymousFunctionSignature"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "explicit"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

anonymousFunctionSignatureImplicit :: Phantoms.TTerm [Syntax.Identifier] -> Phantoms.TTerm Syntax.AnonymousFunctionSignature
anonymousFunctionSignatureImplicit x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AnonymousFunctionSignature"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "implicit"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

anonymousMethodExpression :: Phantoms.TTerm Bool -> Phantoms.TTerm [Syntax.ExplicitAnonymousFunctionParameter] -> Phantoms.TTerm Syntax.Block -> Phantoms.TTerm Syntax.AnonymousMethodExpression
anonymousMethodExpression async signature body =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.AnonymousMethodExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "async"),
          Core.fieldTerm = (Phantoms.unTTerm async)},
        Core.Field {
          Core.fieldName = (Core.Name "signature"),
          Core.fieldTerm = (Phantoms.unTTerm signature)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)}]}))

anonymousMethodExpressionAsync :: Phantoms.TTerm Syntax.AnonymousMethodExpression -> Phantoms.TTerm Bool
anonymousMethodExpressionAsync x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AnonymousMethodExpression"),
        Core.projectionField = (Core.Name "async")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

anonymousMethodExpressionBody :: Phantoms.TTerm Syntax.AnonymousMethodExpression -> Phantoms.TTerm Syntax.Block
anonymousMethodExpressionBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AnonymousMethodExpression"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

anonymousMethodExpressionSignature :: Phantoms.TTerm Syntax.AnonymousMethodExpression -> Phantoms.TTerm [Syntax.ExplicitAnonymousFunctionParameter]
anonymousMethodExpressionSignature x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AnonymousMethodExpression"),
        Core.projectionField = (Core.Name "signature")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

anonymousMethodExpressionWithAsync :: Phantoms.TTerm Syntax.AnonymousMethodExpression -> Phantoms.TTerm Bool -> Phantoms.TTerm Syntax.AnonymousMethodExpression
anonymousMethodExpressionWithAsync original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.AnonymousMethodExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "async"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "signature"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AnonymousMethodExpression"),
              Core.projectionField = (Core.Name "signature")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AnonymousMethodExpression"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

anonymousMethodExpressionWithBody :: Phantoms.TTerm Syntax.AnonymousMethodExpression -> Phantoms.TTerm Syntax.Block -> Phantoms.TTerm Syntax.AnonymousMethodExpression
anonymousMethodExpressionWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.AnonymousMethodExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "async"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AnonymousMethodExpression"),
              Core.projectionField = (Core.Name "async")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "signature"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AnonymousMethodExpression"),
              Core.projectionField = (Core.Name "signature")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

anonymousMethodExpressionWithSignature :: Phantoms.TTerm Syntax.AnonymousMethodExpression -> Phantoms.TTerm [Syntax.ExplicitAnonymousFunctionParameter] -> Phantoms.TTerm Syntax.AnonymousMethodExpression
anonymousMethodExpressionWithSignature original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.AnonymousMethodExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "async"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AnonymousMethodExpression"),
              Core.projectionField = (Core.Name "async")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "signature"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AnonymousMethodExpression"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

argument :: Phantoms.TTerm (Maybe Syntax.Identifier) -> Phantoms.TTerm Syntax.ArgumentValue -> Phantoms.TTerm Syntax.Argument
argument name value =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.Argument"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm name)},
        Core.Field {
          Core.fieldName = (Core.Name "value"),
          Core.fieldTerm = (Phantoms.unTTerm value)}]}))

argumentList :: Phantoms.TTerm [Syntax.Argument] -> Phantoms.TTerm Syntax.ArgumentList
argumentList x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.ArgumentList"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

argumentName :: Phantoms.TTerm Syntax.Argument -> Phantoms.TTerm (Maybe Syntax.Identifier)
argumentName x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.Argument"),
        Core.projectionField = (Core.Name "name")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

argumentValue :: Phantoms.TTerm Syntax.Argument -> Phantoms.TTerm Syntax.ArgumentValue
argumentValue x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.Argument"),
        Core.projectionField = (Core.Name "value")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

argumentValueExpression :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.ArgumentValue
argumentValueExpression x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ArgumentValue"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "expression"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

argumentValueIn :: Phantoms.TTerm Syntax.VariableReference -> Phantoms.TTerm Syntax.ArgumentValue
argumentValueIn x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ArgumentValue"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "in"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

argumentValueOut :: Phantoms.TTerm Syntax.VariableReference -> Phantoms.TTerm Syntax.ArgumentValue
argumentValueOut x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ArgumentValue"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "out"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

argumentValueRef :: Phantoms.TTerm Syntax.VariableReference -> Phantoms.TTerm Syntax.ArgumentValue
argumentValueRef x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ArgumentValue"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "ref"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

argumentWithName :: Phantoms.TTerm Syntax.Argument -> Phantoms.TTerm (Maybe Syntax.Identifier) -> Phantoms.TTerm Syntax.Argument
argumentWithName original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.Argument"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "value"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.Argument"),
              Core.projectionField = (Core.Name "value")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

argumentWithValue :: Phantoms.TTerm Syntax.Argument -> Phantoms.TTerm Syntax.ArgumentValue -> Phantoms.TTerm Syntax.Argument
argumentWithValue original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.Argument"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.Argument"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "value"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

arrayCreationExpressionArrayType :: Phantoms.TTerm Syntax.ArrayTypeArrayCreationExpression -> Phantoms.TTerm Syntax.ArrayCreationExpression
arrayCreationExpressionArrayType x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ArrayCreationExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "arrayType"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

arrayCreationExpressionNonArrayType :: Phantoms.TTerm Syntax.NonArrayTypeArrayCreationExpression -> Phantoms.TTerm Syntax.ArrayCreationExpression
arrayCreationExpressionNonArrayType x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ArrayCreationExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "nonArrayType"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

arrayCreationExpressionRankSpecifier :: Phantoms.TTerm Syntax.RankSpecifierArrayCreationExpression -> Phantoms.TTerm Syntax.ArrayCreationExpression
arrayCreationExpressionRankSpecifier x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ArrayCreationExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "rankSpecifier"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

arrayInitializer :: Phantoms.TTerm [Syntax.VariableInitializer] -> Phantoms.TTerm Syntax.ArrayInitializer
arrayInitializer x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.ArrayInitializer"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

arrayType :: Phantoms.TTerm Syntax.NonArrayType -> Phantoms.TTerm [Syntax.RankSpecifier] -> Phantoms.TTerm Syntax.ArrayType
arrayType type_ rank =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ArrayType"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "rank"),
          Core.fieldTerm = (Phantoms.unTTerm rank)}]}))

arrayTypeArrayCreationExpression :: Phantoms.TTerm Syntax.ArrayType -> Phantoms.TTerm Syntax.ArrayInitializer -> Phantoms.TTerm Syntax.ArrayTypeArrayCreationExpression
arrayTypeArrayCreationExpression type_ initializer =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ArrayTypeArrayCreationExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Phantoms.unTTerm initializer)}]}))

arrayTypeArrayCreationExpressionInitializer :: Phantoms.TTerm Syntax.ArrayTypeArrayCreationExpression -> Phantoms.TTerm Syntax.ArrayInitializer
arrayTypeArrayCreationExpressionInitializer x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ArrayTypeArrayCreationExpression"),
        Core.projectionField = (Core.Name "initializer")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

arrayTypeArrayCreationExpressionType :: Phantoms.TTerm Syntax.ArrayTypeArrayCreationExpression -> Phantoms.TTerm Syntax.ArrayType
arrayTypeArrayCreationExpressionType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ArrayTypeArrayCreationExpression"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

arrayTypeArrayCreationExpressionWithInitializer :: Phantoms.TTerm Syntax.ArrayTypeArrayCreationExpression -> Phantoms.TTerm Syntax.ArrayInitializer -> Phantoms.TTerm Syntax.ArrayTypeArrayCreationExpression
arrayTypeArrayCreationExpressionWithInitializer original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ArrayTypeArrayCreationExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ArrayTypeArrayCreationExpression"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

arrayTypeArrayCreationExpressionWithType :: Phantoms.TTerm Syntax.ArrayTypeArrayCreationExpression -> Phantoms.TTerm Syntax.ArrayType -> Phantoms.TTerm Syntax.ArrayTypeArrayCreationExpression
arrayTypeArrayCreationExpressionWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ArrayTypeArrayCreationExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ArrayTypeArrayCreationExpression"),
              Core.projectionField = (Core.Name "initializer")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

arrayTypeRank :: Phantoms.TTerm Syntax.ArrayType -> Phantoms.TTerm [Syntax.RankSpecifier]
arrayTypeRank x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ArrayType"),
        Core.projectionField = (Core.Name "rank")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

arrayTypeType :: Phantoms.TTerm Syntax.ArrayType -> Phantoms.TTerm Syntax.NonArrayType
arrayTypeType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ArrayType"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

arrayTypeWithRank :: Phantoms.TTerm Syntax.ArrayType -> Phantoms.TTerm [Syntax.RankSpecifier] -> Phantoms.TTerm Syntax.ArrayType
arrayTypeWithRank original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ArrayType"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ArrayType"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "rank"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

arrayTypeWithType :: Phantoms.TTerm Syntax.ArrayType -> Phantoms.TTerm Syntax.NonArrayType -> Phantoms.TTerm Syntax.ArrayType
arrayTypeWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ArrayType"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "rank"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ArrayType"),
              Core.projectionField = (Core.Name "rank")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

asTypeExpression :: Phantoms.TTerm Syntax.RelationalExpression -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.AsTypeExpression
asTypeExpression expression type_ =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.AsTypeExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm expression)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)}]}))

asTypeExpressionExpression :: Phantoms.TTerm Syntax.AsTypeExpression -> Phantoms.TTerm Syntax.RelationalExpression
asTypeExpressionExpression x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AsTypeExpression"),
        Core.projectionField = (Core.Name "expression")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

asTypeExpressionType :: Phantoms.TTerm Syntax.AsTypeExpression -> Phantoms.TTerm Syntax.Type
asTypeExpressionType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AsTypeExpression"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

asTypeExpressionWithExpression :: Phantoms.TTerm Syntax.AsTypeExpression -> Phantoms.TTerm Syntax.RelationalExpression -> Phantoms.TTerm Syntax.AsTypeExpression
asTypeExpressionWithExpression original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.AsTypeExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AsTypeExpression"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

asTypeExpressionWithType :: Phantoms.TTerm Syntax.AsTypeExpression -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.AsTypeExpression
asTypeExpressionWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.AsTypeExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AsTypeExpression"),
              Core.projectionField = (Core.Name "expression")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

assignment :: Phantoms.TTerm Syntax.UnaryExpression -> Phantoms.TTerm Syntax.AssignmentOperator -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.Assignment
assignment left operator right =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.Assignment"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Phantoms.unTTerm left)},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Phantoms.unTTerm operator)},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Phantoms.unTTerm right)}]}))

assignmentLeft :: Phantoms.TTerm Syntax.Assignment -> Phantoms.TTerm Syntax.UnaryExpression
assignmentLeft x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.Assignment"),
        Core.projectionField = (Core.Name "left")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

assignmentMemberDeclarator :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.AssignmentMemberDeclarator
assignmentMemberDeclarator identifier expression =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.AssignmentMemberDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm identifier)},
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm expression)}]}))

assignmentMemberDeclaratorExpression :: Phantoms.TTerm Syntax.AssignmentMemberDeclarator -> Phantoms.TTerm Syntax.Expression
assignmentMemberDeclaratorExpression x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AssignmentMemberDeclarator"),
        Core.projectionField = (Core.Name "expression")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

assignmentMemberDeclaratorIdentifier :: Phantoms.TTerm Syntax.AssignmentMemberDeclarator -> Phantoms.TTerm Syntax.Identifier
assignmentMemberDeclaratorIdentifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AssignmentMemberDeclarator"),
        Core.projectionField = (Core.Name "identifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

assignmentMemberDeclaratorWithExpression :: Phantoms.TTerm Syntax.AssignmentMemberDeclarator -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.AssignmentMemberDeclarator
assignmentMemberDeclaratorWithExpression original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.AssignmentMemberDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AssignmentMemberDeclarator"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

assignmentMemberDeclaratorWithIdentifier :: Phantoms.TTerm Syntax.AssignmentMemberDeclarator -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.AssignmentMemberDeclarator
assignmentMemberDeclaratorWithIdentifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.AssignmentMemberDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AssignmentMemberDeclarator"),
              Core.projectionField = (Core.Name "expression")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

assignmentOperator :: Phantoms.TTerm Syntax.Assignment -> Phantoms.TTerm Syntax.AssignmentOperator
assignmentOperator x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.Assignment"),
        Core.projectionField = (Core.Name "operator")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

assignmentOperatorAndEquals :: Phantoms.TTerm Syntax.AssignmentOperator
assignmentOperatorAndEquals =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AssignmentOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "andEquals"),
        Core.fieldTerm = Core.TermUnit}}))

assignmentOperatorDivideEquals :: Phantoms.TTerm Syntax.AssignmentOperator
assignmentOperatorDivideEquals =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AssignmentOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "divideEquals"),
        Core.fieldTerm = Core.TermUnit}}))

assignmentOperatorLeftShiftEquals :: Phantoms.TTerm Syntax.AssignmentOperator
assignmentOperatorLeftShiftEquals =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AssignmentOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "leftShiftEquals"),
        Core.fieldTerm = Core.TermUnit}}))

assignmentOperatorMinusEquals :: Phantoms.TTerm Syntax.AssignmentOperator
assignmentOperatorMinusEquals =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AssignmentOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "minusEquals"),
        Core.fieldTerm = Core.TermUnit}}))

assignmentOperatorModEquals :: Phantoms.TTerm Syntax.AssignmentOperator
assignmentOperatorModEquals =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AssignmentOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "modEquals"),
        Core.fieldTerm = Core.TermUnit}}))

assignmentOperatorOrEquals :: Phantoms.TTerm Syntax.AssignmentOperator
assignmentOperatorOrEquals =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AssignmentOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "orEquals"),
        Core.fieldTerm = Core.TermUnit}}))

assignmentOperatorPlusEquals :: Phantoms.TTerm Syntax.AssignmentOperator
assignmentOperatorPlusEquals =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AssignmentOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "plusEquals"),
        Core.fieldTerm = Core.TermUnit}}))

assignmentOperatorRightShiftEquals :: Phantoms.TTerm Syntax.AssignmentOperator
assignmentOperatorRightShiftEquals =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AssignmentOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "rightShiftEquals"),
        Core.fieldTerm = Core.TermUnit}}))

assignmentOperatorSimple :: Phantoms.TTerm Bool -> Phantoms.TTerm Syntax.AssignmentOperator
assignmentOperatorSimple x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AssignmentOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "simple"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

assignmentOperatorTimesEquals :: Phantoms.TTerm Syntax.AssignmentOperator
assignmentOperatorTimesEquals =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AssignmentOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "timesEquals"),
        Core.fieldTerm = Core.TermUnit}}))

assignmentOperatorXorEquals :: Phantoms.TTerm Syntax.AssignmentOperator
assignmentOperatorXorEquals =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AssignmentOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "xorEquals"),
        Core.fieldTerm = Core.TermUnit}}))

assignmentRight :: Phantoms.TTerm Syntax.Assignment -> Phantoms.TTerm Syntax.Expression
assignmentRight x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.Assignment"),
        Core.projectionField = (Core.Name "right")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

assignmentWithLeft :: Phantoms.TTerm Syntax.Assignment -> Phantoms.TTerm Syntax.UnaryExpression -> Phantoms.TTerm Syntax.Assignment
assignmentWithLeft original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.Assignment"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.Assignment"),
              Core.projectionField = (Core.Name "operator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.Assignment"),
              Core.projectionField = (Core.Name "right")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

assignmentWithOperator :: Phantoms.TTerm Syntax.Assignment -> Phantoms.TTerm Syntax.AssignmentOperator -> Phantoms.TTerm Syntax.Assignment
assignmentWithOperator original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.Assignment"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.Assignment"),
              Core.projectionField = (Core.Name "left")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.Assignment"),
              Core.projectionField = (Core.Name "right")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

assignmentWithRight :: Phantoms.TTerm Syntax.Assignment -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.Assignment
assignmentWithRight original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.Assignment"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.Assignment"),
              Core.projectionField = (Core.Name "left")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.Assignment"),
              Core.projectionField = (Core.Name "operator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

attribute :: Phantoms.TTerm Syntax.AttributeName -> Phantoms.TTerm (Maybe Syntax.AttributeArguments) -> Phantoms.TTerm Syntax.Attribute
attribute name arguments =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.Attribute"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm name)},
        Core.Field {
          Core.fieldName = (Core.Name "arguments"),
          Core.fieldTerm = (Phantoms.unTTerm arguments)}]}))

attributeArgumentExpression :: Phantoms.TTerm Syntax.NonAssignmentExpression -> Phantoms.TTerm Syntax.AttributeArgumentExpression
attributeArgumentExpression x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.AttributeArgumentExpression"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

attributeArguments :: Phantoms.TTerm Syntax.Attribute -> Phantoms.TTerm (Maybe Syntax.AttributeArguments)
attributeArguments x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.Attribute"),
        Core.projectionField = (Core.Name "arguments")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

attributeArgumentsNamed :: Phantoms.TTerm Syntax.AttributeArguments -> Phantoms.TTerm (Maybe Syntax.NamedArgumentList)
attributeArgumentsNamed x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AttributeArguments"),
        Core.projectionField = (Core.Name "named")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

attributeArgumentsPositonal :: Phantoms.TTerm Syntax.AttributeArguments -> Phantoms.TTerm (Maybe Syntax.PositionalArgumentList)
attributeArgumentsPositonal x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AttributeArguments"),
        Core.projectionField = (Core.Name "positonal")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

attributeArgumentsWithNamed :: Phantoms.TTerm Syntax.AttributeArguments -> Phantoms.TTerm (Maybe Syntax.NamedArgumentList) -> Phantoms.TTerm Syntax.AttributeArguments
attributeArgumentsWithNamed original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.AttributeArguments"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "positonal"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AttributeArguments"),
              Core.projectionField = (Core.Name "positonal")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "named"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

attributeArgumentsWithPositonal :: Phantoms.TTerm Syntax.AttributeArguments -> Phantoms.TTerm (Maybe Syntax.PositionalArgumentList) -> Phantoms.TTerm Syntax.AttributeArguments
attributeArgumentsWithPositonal original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.AttributeArguments"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "positonal"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "named"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AttributeArguments"),
              Core.projectionField = (Core.Name "named")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

attributeArguments_ :: Phantoms.TTerm (Maybe Syntax.PositionalArgumentList) -> Phantoms.TTerm (Maybe Syntax.NamedArgumentList) -> Phantoms.TTerm Syntax.AttributeArguments
attributeArguments_ positonal named =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.AttributeArguments"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "positonal"),
          Core.fieldTerm = (Phantoms.unTTerm positonal)},
        Core.Field {
          Core.fieldName = (Core.Name "named"),
          Core.fieldTerm = (Phantoms.unTTerm named)}]}))

attributeList :: Phantoms.TTerm [Syntax.Attribute] -> Phantoms.TTerm Syntax.AttributeList
attributeList x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.AttributeList"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

attributeName :: Phantoms.TTerm Syntax.Attribute -> Phantoms.TTerm Syntax.AttributeName
attributeName x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.Attribute"),
        Core.projectionField = (Core.Name "name")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

attributeName_ :: Phantoms.TTerm Syntax.TypeName -> Phantoms.TTerm Syntax.AttributeName
attributeName_ x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.AttributeName"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

attributeSection :: Phantoms.TTerm (Maybe Syntax.AttributeTarget) -> Phantoms.TTerm Syntax.AttributeList -> Phantoms.TTerm Syntax.AttributeSection
attributeSection target attributes =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.AttributeSection"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "target"),
          Core.fieldTerm = (Phantoms.unTTerm target)},
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)}]}))

attributeSectionAttributes :: Phantoms.TTerm Syntax.AttributeSection -> Phantoms.TTerm Syntax.AttributeList
attributeSectionAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AttributeSection"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

attributeSectionTarget :: Phantoms.TTerm Syntax.AttributeSection -> Phantoms.TTerm (Maybe Syntax.AttributeTarget)
attributeSectionTarget x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AttributeSection"),
        Core.projectionField = (Core.Name "target")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

attributeSectionWithAttributes :: Phantoms.TTerm Syntax.AttributeSection -> Phantoms.TTerm Syntax.AttributeList -> Phantoms.TTerm Syntax.AttributeSection
attributeSectionWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.AttributeSection"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "target"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AttributeSection"),
              Core.projectionField = (Core.Name "target")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

attributeSectionWithTarget :: Phantoms.TTerm Syntax.AttributeSection -> Phantoms.TTerm (Maybe Syntax.AttributeTarget) -> Phantoms.TTerm Syntax.AttributeSection
attributeSectionWithTarget original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.AttributeSection"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "target"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.AttributeSection"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

attributeTargetIdentifier :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.AttributeTarget
attributeTargetIdentifier x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AttributeTarget"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "identifier"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

attributeTargetKeyword :: Phantoms.TTerm Syntax.Keyword -> Phantoms.TTerm Syntax.AttributeTarget
attributeTargetKeyword x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.AttributeTarget"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "keyword"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

attributeWithArguments :: Phantoms.TTerm Syntax.Attribute -> Phantoms.TTerm (Maybe Syntax.AttributeArguments) -> Phantoms.TTerm Syntax.Attribute
attributeWithArguments original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.Attribute"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.Attribute"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "arguments"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

attributeWithName :: Phantoms.TTerm Syntax.Attribute -> Phantoms.TTerm Syntax.AttributeName -> Phantoms.TTerm Syntax.Attribute
attributeWithName original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.Attribute"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "arguments"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.Attribute"),
              Core.projectionField = (Core.Name "arguments")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

attributes :: Phantoms.TTerm [Syntax.AttributeSection] -> Phantoms.TTerm Syntax.Attributes
attributes x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.Attributes"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

baseAccessArguments :: Phantoms.TTerm Syntax.ArgumentList -> Phantoms.TTerm Syntax.BaseAccess
baseAccessArguments x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.BaseAccess"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "arguments"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

baseAccessIdentifier :: Phantoms.TTerm Syntax.BaseAccessWithIdentifier -> Phantoms.TTerm Syntax.BaseAccess
baseAccessIdentifier x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.BaseAccess"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "identifier"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

baseAccessWithIdentifier :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList) -> Phantoms.TTerm Syntax.BaseAccessWithIdentifier
baseAccessWithIdentifier identifier typeArguments =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BaseAccessWithIdentifier"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm identifier)},
        Core.Field {
          Core.fieldName = (Core.Name "typeArguments"),
          Core.fieldTerm = (Phantoms.unTTerm typeArguments)}]}))

baseAccessWithIdentifierIdentifier :: Phantoms.TTerm Syntax.BaseAccessWithIdentifier -> Phantoms.TTerm Syntax.Identifier
baseAccessWithIdentifierIdentifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BaseAccessWithIdentifier"),
        Core.projectionField = (Core.Name "identifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

baseAccessWithIdentifierTypeArguments :: Phantoms.TTerm Syntax.BaseAccessWithIdentifier -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList)
baseAccessWithIdentifierTypeArguments x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BaseAccessWithIdentifier"),
        Core.projectionField = (Core.Name "typeArguments")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

baseAccessWithIdentifierWithIdentifier :: Phantoms.TTerm Syntax.BaseAccessWithIdentifier -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.BaseAccessWithIdentifier
baseAccessWithIdentifierWithIdentifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BaseAccessWithIdentifier"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "typeArguments"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BaseAccessWithIdentifier"),
              Core.projectionField = (Core.Name "typeArguments")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

baseAccessWithIdentifierWithTypeArguments :: Phantoms.TTerm Syntax.BaseAccessWithIdentifier -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList) -> Phantoms.TTerm Syntax.BaseAccessWithIdentifier
baseAccessWithIdentifierWithTypeArguments original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BaseAccessWithIdentifier"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BaseAccessWithIdentifier"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "typeArguments"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

binaryAdditiveExpression :: Phantoms.TTerm Syntax.AdditiveExpression -> Phantoms.TTerm Syntax.AdditiveOperator -> Phantoms.TTerm Syntax.MultiplicativeExpression -> Phantoms.TTerm Syntax.BinaryAdditiveExpression
binaryAdditiveExpression left operator right =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryAdditiveExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Phantoms.unTTerm left)},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Phantoms.unTTerm operator)},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Phantoms.unTTerm right)}]}))

binaryAdditiveExpressionLeft :: Phantoms.TTerm Syntax.BinaryAdditiveExpression -> Phantoms.TTerm Syntax.AdditiveExpression
binaryAdditiveExpressionLeft x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryAdditiveExpression"),
        Core.projectionField = (Core.Name "left")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

binaryAdditiveExpressionOperator :: Phantoms.TTerm Syntax.BinaryAdditiveExpression -> Phantoms.TTerm Syntax.AdditiveOperator
binaryAdditiveExpressionOperator x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryAdditiveExpression"),
        Core.projectionField = (Core.Name "operator")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

binaryAdditiveExpressionRight :: Phantoms.TTerm Syntax.BinaryAdditiveExpression -> Phantoms.TTerm Syntax.MultiplicativeExpression
binaryAdditiveExpressionRight x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryAdditiveExpression"),
        Core.projectionField = (Core.Name "right")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

binaryAdditiveExpressionWithLeft :: Phantoms.TTerm Syntax.BinaryAdditiveExpression -> Phantoms.TTerm Syntax.AdditiveExpression -> Phantoms.TTerm Syntax.BinaryAdditiveExpression
binaryAdditiveExpressionWithLeft original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryAdditiveExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryAdditiveExpression"),
              Core.projectionField = (Core.Name "operator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryAdditiveExpression"),
              Core.projectionField = (Core.Name "right")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

binaryAdditiveExpressionWithOperator :: Phantoms.TTerm Syntax.BinaryAdditiveExpression -> Phantoms.TTerm Syntax.AdditiveOperator -> Phantoms.TTerm Syntax.BinaryAdditiveExpression
binaryAdditiveExpressionWithOperator original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryAdditiveExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryAdditiveExpression"),
              Core.projectionField = (Core.Name "left")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryAdditiveExpression"),
              Core.projectionField = (Core.Name "right")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

binaryAdditiveExpressionWithRight :: Phantoms.TTerm Syntax.BinaryAdditiveExpression -> Phantoms.TTerm Syntax.MultiplicativeExpression -> Phantoms.TTerm Syntax.BinaryAdditiveExpression
binaryAdditiveExpressionWithRight original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryAdditiveExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryAdditiveExpression"),
              Core.projectionField = (Core.Name "left")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryAdditiveExpression"),
              Core.projectionField = (Core.Name "operator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

binaryAndExpression :: Phantoms.TTerm Syntax.AndExpression -> Phantoms.TTerm Syntax.EqualityExpression -> Phantoms.TTerm Syntax.BinaryAndExpression
binaryAndExpression left right =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryAndExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Phantoms.unTTerm left)},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Phantoms.unTTerm right)}]}))

binaryAndExpressionLeft :: Phantoms.TTerm Syntax.BinaryAndExpression -> Phantoms.TTerm Syntax.AndExpression
binaryAndExpressionLeft x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryAndExpression"),
        Core.projectionField = (Core.Name "left")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

binaryAndExpressionRight :: Phantoms.TTerm Syntax.BinaryAndExpression -> Phantoms.TTerm Syntax.EqualityExpression
binaryAndExpressionRight x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryAndExpression"),
        Core.projectionField = (Core.Name "right")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

binaryAndExpressionWithLeft :: Phantoms.TTerm Syntax.BinaryAndExpression -> Phantoms.TTerm Syntax.AndExpression -> Phantoms.TTerm Syntax.BinaryAndExpression
binaryAndExpressionWithLeft original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryAndExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryAndExpression"),
              Core.projectionField = (Core.Name "right")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

binaryAndExpressionWithRight :: Phantoms.TTerm Syntax.BinaryAndExpression -> Phantoms.TTerm Syntax.EqualityExpression -> Phantoms.TTerm Syntax.BinaryAndExpression
binaryAndExpressionWithRight original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryAndExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryAndExpression"),
              Core.projectionField = (Core.Name "left")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

binaryConditionalAndExpression :: Phantoms.TTerm Syntax.ConditionalAndExpression -> Phantoms.TTerm Syntax.InclusiveOrExpression -> Phantoms.TTerm Syntax.BinaryConditionalAndExpression
binaryConditionalAndExpression left right =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryConditionalAndExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Phantoms.unTTerm left)},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Phantoms.unTTerm right)}]}))

binaryConditionalAndExpressionLeft :: Phantoms.TTerm Syntax.BinaryConditionalAndExpression -> Phantoms.TTerm Syntax.ConditionalAndExpression
binaryConditionalAndExpressionLeft x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryConditionalAndExpression"),
        Core.projectionField = (Core.Name "left")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

binaryConditionalAndExpressionRight :: Phantoms.TTerm Syntax.BinaryConditionalAndExpression -> Phantoms.TTerm Syntax.InclusiveOrExpression
binaryConditionalAndExpressionRight x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryConditionalAndExpression"),
        Core.projectionField = (Core.Name "right")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

binaryConditionalAndExpressionWithLeft :: Phantoms.TTerm Syntax.BinaryConditionalAndExpression -> Phantoms.TTerm Syntax.ConditionalAndExpression -> Phantoms.TTerm Syntax.BinaryConditionalAndExpression
binaryConditionalAndExpressionWithLeft original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryConditionalAndExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryConditionalAndExpression"),
              Core.projectionField = (Core.Name "right")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

binaryConditionalAndExpressionWithRight :: Phantoms.TTerm Syntax.BinaryConditionalAndExpression -> Phantoms.TTerm Syntax.InclusiveOrExpression -> Phantoms.TTerm Syntax.BinaryConditionalAndExpression
binaryConditionalAndExpressionWithRight original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryConditionalAndExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryConditionalAndExpression"),
              Core.projectionField = (Core.Name "left")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

binaryConditionalOrExpression :: Phantoms.TTerm Syntax.ConditionalOrExpression -> Phantoms.TTerm Syntax.ConditionalAndExpression -> Phantoms.TTerm Syntax.BinaryConditionalOrExpression
binaryConditionalOrExpression left right =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryConditionalOrExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Phantoms.unTTerm left)},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Phantoms.unTTerm right)}]}))

binaryConditionalOrExpressionLeft :: Phantoms.TTerm Syntax.BinaryConditionalOrExpression -> Phantoms.TTerm Syntax.ConditionalOrExpression
binaryConditionalOrExpressionLeft x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryConditionalOrExpression"),
        Core.projectionField = (Core.Name "left")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

binaryConditionalOrExpressionRight :: Phantoms.TTerm Syntax.BinaryConditionalOrExpression -> Phantoms.TTerm Syntax.ConditionalAndExpression
binaryConditionalOrExpressionRight x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryConditionalOrExpression"),
        Core.projectionField = (Core.Name "right")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

binaryConditionalOrExpressionWithLeft :: Phantoms.TTerm Syntax.BinaryConditionalOrExpression -> Phantoms.TTerm Syntax.ConditionalOrExpression -> Phantoms.TTerm Syntax.BinaryConditionalOrExpression
binaryConditionalOrExpressionWithLeft original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryConditionalOrExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryConditionalOrExpression"),
              Core.projectionField = (Core.Name "right")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

binaryConditionalOrExpressionWithRight :: Phantoms.TTerm Syntax.BinaryConditionalOrExpression -> Phantoms.TTerm Syntax.ConditionalAndExpression -> Phantoms.TTerm Syntax.BinaryConditionalOrExpression
binaryConditionalOrExpressionWithRight original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryConditionalOrExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryConditionalOrExpression"),
              Core.projectionField = (Core.Name "left")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

binaryEqualityExpression :: Phantoms.TTerm Syntax.EqualityExpression -> Phantoms.TTerm Syntax.EqualityOperator -> Phantoms.TTerm Syntax.RelationalExpression -> Phantoms.TTerm Syntax.BinaryEqualityExpression
binaryEqualityExpression left operator right =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryEqualityExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Phantoms.unTTerm left)},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Phantoms.unTTerm operator)},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Phantoms.unTTerm right)}]}))

binaryEqualityExpressionLeft :: Phantoms.TTerm Syntax.BinaryEqualityExpression -> Phantoms.TTerm Syntax.EqualityExpression
binaryEqualityExpressionLeft x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryEqualityExpression"),
        Core.projectionField = (Core.Name "left")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

binaryEqualityExpressionOperator :: Phantoms.TTerm Syntax.BinaryEqualityExpression -> Phantoms.TTerm Syntax.EqualityOperator
binaryEqualityExpressionOperator x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryEqualityExpression"),
        Core.projectionField = (Core.Name "operator")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

binaryEqualityExpressionRight :: Phantoms.TTerm Syntax.BinaryEqualityExpression -> Phantoms.TTerm Syntax.RelationalExpression
binaryEqualityExpressionRight x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryEqualityExpression"),
        Core.projectionField = (Core.Name "right")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

binaryEqualityExpressionWithLeft :: Phantoms.TTerm Syntax.BinaryEqualityExpression -> Phantoms.TTerm Syntax.EqualityExpression -> Phantoms.TTerm Syntax.BinaryEqualityExpression
binaryEqualityExpressionWithLeft original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryEqualityExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryEqualityExpression"),
              Core.projectionField = (Core.Name "operator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryEqualityExpression"),
              Core.projectionField = (Core.Name "right")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

binaryEqualityExpressionWithOperator :: Phantoms.TTerm Syntax.BinaryEqualityExpression -> Phantoms.TTerm Syntax.EqualityOperator -> Phantoms.TTerm Syntax.BinaryEqualityExpression
binaryEqualityExpressionWithOperator original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryEqualityExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryEqualityExpression"),
              Core.projectionField = (Core.Name "left")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryEqualityExpression"),
              Core.projectionField = (Core.Name "right")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

binaryEqualityExpressionWithRight :: Phantoms.TTerm Syntax.BinaryEqualityExpression -> Phantoms.TTerm Syntax.RelationalExpression -> Phantoms.TTerm Syntax.BinaryEqualityExpression
binaryEqualityExpressionWithRight original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryEqualityExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryEqualityExpression"),
              Core.projectionField = (Core.Name "left")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryEqualityExpression"),
              Core.projectionField = (Core.Name "operator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

binaryExclusiveOrExpression :: Phantoms.TTerm Syntax.ExclusiveOrExpression -> Phantoms.TTerm Syntax.AndExpression -> Phantoms.TTerm Syntax.BinaryExclusiveOrExpression
binaryExclusiveOrExpression left right =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryExclusiveOrExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Phantoms.unTTerm left)},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Phantoms.unTTerm right)}]}))

binaryExclusiveOrExpressionLeft :: Phantoms.TTerm Syntax.BinaryExclusiveOrExpression -> Phantoms.TTerm Syntax.ExclusiveOrExpression
binaryExclusiveOrExpressionLeft x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryExclusiveOrExpression"),
        Core.projectionField = (Core.Name "left")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

binaryExclusiveOrExpressionRight :: Phantoms.TTerm Syntax.BinaryExclusiveOrExpression -> Phantoms.TTerm Syntax.AndExpression
binaryExclusiveOrExpressionRight x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryExclusiveOrExpression"),
        Core.projectionField = (Core.Name "right")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

binaryExclusiveOrExpressionWithLeft :: Phantoms.TTerm Syntax.BinaryExclusiveOrExpression -> Phantoms.TTerm Syntax.ExclusiveOrExpression -> Phantoms.TTerm Syntax.BinaryExclusiveOrExpression
binaryExclusiveOrExpressionWithLeft original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryExclusiveOrExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryExclusiveOrExpression"),
              Core.projectionField = (Core.Name "right")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

binaryExclusiveOrExpressionWithRight :: Phantoms.TTerm Syntax.BinaryExclusiveOrExpression -> Phantoms.TTerm Syntax.AndExpression -> Phantoms.TTerm Syntax.BinaryExclusiveOrExpression
binaryExclusiveOrExpressionWithRight original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryExclusiveOrExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryExclusiveOrExpression"),
              Core.projectionField = (Core.Name "left")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

binaryInclusiveOrExpression :: Phantoms.TTerm Syntax.InclusiveOrExpression -> Phantoms.TTerm Syntax.ExclusiveOrExpression -> Phantoms.TTerm Syntax.BinaryInclusiveOrExpression
binaryInclusiveOrExpression left right =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryInclusiveOrExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Phantoms.unTTerm left)},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Phantoms.unTTerm right)}]}))

binaryInclusiveOrExpressionLeft :: Phantoms.TTerm Syntax.BinaryInclusiveOrExpression -> Phantoms.TTerm Syntax.InclusiveOrExpression
binaryInclusiveOrExpressionLeft x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryInclusiveOrExpression"),
        Core.projectionField = (Core.Name "left")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

binaryInclusiveOrExpressionRight :: Phantoms.TTerm Syntax.BinaryInclusiveOrExpression -> Phantoms.TTerm Syntax.ExclusiveOrExpression
binaryInclusiveOrExpressionRight x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryInclusiveOrExpression"),
        Core.projectionField = (Core.Name "right")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

binaryInclusiveOrExpressionWithLeft :: Phantoms.TTerm Syntax.BinaryInclusiveOrExpression -> Phantoms.TTerm Syntax.InclusiveOrExpression -> Phantoms.TTerm Syntax.BinaryInclusiveOrExpression
binaryInclusiveOrExpressionWithLeft original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryInclusiveOrExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryInclusiveOrExpression"),
              Core.projectionField = (Core.Name "right")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

binaryInclusiveOrExpressionWithRight :: Phantoms.TTerm Syntax.BinaryInclusiveOrExpression -> Phantoms.TTerm Syntax.ExclusiveOrExpression -> Phantoms.TTerm Syntax.BinaryInclusiveOrExpression
binaryInclusiveOrExpressionWithRight original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryInclusiveOrExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryInclusiveOrExpression"),
              Core.projectionField = (Core.Name "left")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

binaryMultiplicativeExpression :: Phantoms.TTerm Syntax.MultiplicativeExpression -> Phantoms.TTerm Syntax.MultiplicativeOperator -> Phantoms.TTerm Syntax.UnaryExpression -> Phantoms.TTerm Syntax.BinaryMultiplicativeExpression
binaryMultiplicativeExpression left operator right =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryMultiplicativeExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Phantoms.unTTerm left)},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Phantoms.unTTerm operator)},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Phantoms.unTTerm right)}]}))

binaryMultiplicativeExpressionLeft :: Phantoms.TTerm Syntax.BinaryMultiplicativeExpression -> Phantoms.TTerm Syntax.MultiplicativeExpression
binaryMultiplicativeExpressionLeft x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryMultiplicativeExpression"),
        Core.projectionField = (Core.Name "left")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

binaryMultiplicativeExpressionOperator :: Phantoms.TTerm Syntax.BinaryMultiplicativeExpression -> Phantoms.TTerm Syntax.MultiplicativeOperator
binaryMultiplicativeExpressionOperator x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryMultiplicativeExpression"),
        Core.projectionField = (Core.Name "operator")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

binaryMultiplicativeExpressionRight :: Phantoms.TTerm Syntax.BinaryMultiplicativeExpression -> Phantoms.TTerm Syntax.UnaryExpression
binaryMultiplicativeExpressionRight x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryMultiplicativeExpression"),
        Core.projectionField = (Core.Name "right")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

binaryMultiplicativeExpressionWithLeft :: Phantoms.TTerm Syntax.BinaryMultiplicativeExpression -> Phantoms.TTerm Syntax.MultiplicativeExpression -> Phantoms.TTerm Syntax.BinaryMultiplicativeExpression
binaryMultiplicativeExpressionWithLeft original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryMultiplicativeExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryMultiplicativeExpression"),
              Core.projectionField = (Core.Name "operator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryMultiplicativeExpression"),
              Core.projectionField = (Core.Name "right")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

binaryMultiplicativeExpressionWithOperator :: Phantoms.TTerm Syntax.BinaryMultiplicativeExpression -> Phantoms.TTerm Syntax.MultiplicativeOperator -> Phantoms.TTerm Syntax.BinaryMultiplicativeExpression
binaryMultiplicativeExpressionWithOperator original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryMultiplicativeExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryMultiplicativeExpression"),
              Core.projectionField = (Core.Name "left")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryMultiplicativeExpression"),
              Core.projectionField = (Core.Name "right")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

binaryMultiplicativeExpressionWithRight :: Phantoms.TTerm Syntax.BinaryMultiplicativeExpression -> Phantoms.TTerm Syntax.UnaryExpression -> Phantoms.TTerm Syntax.BinaryMultiplicativeExpression
binaryMultiplicativeExpressionWithRight original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryMultiplicativeExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryMultiplicativeExpression"),
              Core.projectionField = (Core.Name "left")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryMultiplicativeExpression"),
              Core.projectionField = (Core.Name "operator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

binaryNullCoalescingExpression :: Phantoms.TTerm Syntax.ConditionalOrExpression -> Phantoms.TTerm Syntax.NullCoalescingExpression -> Phantoms.TTerm Syntax.BinaryNullCoalescingExpression
binaryNullCoalescingExpression left right =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryNullCoalescingExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Phantoms.unTTerm left)},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Phantoms.unTTerm right)}]}))

binaryNullCoalescingExpressionLeft :: Phantoms.TTerm Syntax.BinaryNullCoalescingExpression -> Phantoms.TTerm Syntax.ConditionalOrExpression
binaryNullCoalescingExpressionLeft x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryNullCoalescingExpression"),
        Core.projectionField = (Core.Name "left")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

binaryNullCoalescingExpressionRight :: Phantoms.TTerm Syntax.BinaryNullCoalescingExpression -> Phantoms.TTerm Syntax.NullCoalescingExpression
binaryNullCoalescingExpressionRight x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryNullCoalescingExpression"),
        Core.projectionField = (Core.Name "right")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

binaryNullCoalescingExpressionWithLeft :: Phantoms.TTerm Syntax.BinaryNullCoalescingExpression -> Phantoms.TTerm Syntax.ConditionalOrExpression -> Phantoms.TTerm Syntax.BinaryNullCoalescingExpression
binaryNullCoalescingExpressionWithLeft original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryNullCoalescingExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryNullCoalescingExpression"),
              Core.projectionField = (Core.Name "right")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

binaryNullCoalescingExpressionWithRight :: Phantoms.TTerm Syntax.BinaryNullCoalescingExpression -> Phantoms.TTerm Syntax.NullCoalescingExpression -> Phantoms.TTerm Syntax.BinaryNullCoalescingExpression
binaryNullCoalescingExpressionWithRight original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryNullCoalescingExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryNullCoalescingExpression"),
              Core.projectionField = (Core.Name "left")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

binaryOperatorDeclarator :: Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.OverloadableBinaryOperator -> Phantoms.TTerm Syntax.FixedParameter -> Phantoms.TTerm Syntax.FixedParameter -> Phantoms.TTerm Syntax.BinaryOperatorDeclarator
binaryOperatorDeclarator type_ operator left right =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryOperatorDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Phantoms.unTTerm operator)},
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Phantoms.unTTerm left)},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Phantoms.unTTerm right)}]}))

binaryOperatorDeclaratorLeft :: Phantoms.TTerm Syntax.BinaryOperatorDeclarator -> Phantoms.TTerm Syntax.FixedParameter
binaryOperatorDeclaratorLeft x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryOperatorDeclarator"),
        Core.projectionField = (Core.Name "left")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

binaryOperatorDeclaratorOperator :: Phantoms.TTerm Syntax.BinaryOperatorDeclarator -> Phantoms.TTerm Syntax.OverloadableBinaryOperator
binaryOperatorDeclaratorOperator x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryOperatorDeclarator"),
        Core.projectionField = (Core.Name "operator")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

binaryOperatorDeclaratorRight :: Phantoms.TTerm Syntax.BinaryOperatorDeclarator -> Phantoms.TTerm Syntax.FixedParameter
binaryOperatorDeclaratorRight x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryOperatorDeclarator"),
        Core.projectionField = (Core.Name "right")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

binaryOperatorDeclaratorType :: Phantoms.TTerm Syntax.BinaryOperatorDeclarator -> Phantoms.TTerm Syntax.Type
binaryOperatorDeclaratorType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryOperatorDeclarator"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

binaryOperatorDeclaratorWithLeft :: Phantoms.TTerm Syntax.BinaryOperatorDeclarator -> Phantoms.TTerm Syntax.FixedParameter -> Phantoms.TTerm Syntax.BinaryOperatorDeclarator
binaryOperatorDeclaratorWithLeft original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryOperatorDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryOperatorDeclarator"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryOperatorDeclarator"),
              Core.projectionField = (Core.Name "operator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryOperatorDeclarator"),
              Core.projectionField = (Core.Name "right")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

binaryOperatorDeclaratorWithOperator :: Phantoms.TTerm Syntax.BinaryOperatorDeclarator -> Phantoms.TTerm Syntax.OverloadableBinaryOperator -> Phantoms.TTerm Syntax.BinaryOperatorDeclarator
binaryOperatorDeclaratorWithOperator original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryOperatorDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryOperatorDeclarator"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryOperatorDeclarator"),
              Core.projectionField = (Core.Name "left")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryOperatorDeclarator"),
              Core.projectionField = (Core.Name "right")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

binaryOperatorDeclaratorWithRight :: Phantoms.TTerm Syntax.BinaryOperatorDeclarator -> Phantoms.TTerm Syntax.FixedParameter -> Phantoms.TTerm Syntax.BinaryOperatorDeclarator
binaryOperatorDeclaratorWithRight original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryOperatorDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryOperatorDeclarator"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryOperatorDeclarator"),
              Core.projectionField = (Core.Name "operator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryOperatorDeclarator"),
              Core.projectionField = (Core.Name "left")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

binaryOperatorDeclaratorWithType :: Phantoms.TTerm Syntax.BinaryOperatorDeclarator -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.BinaryOperatorDeclarator
binaryOperatorDeclaratorWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryOperatorDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryOperatorDeclarator"),
              Core.projectionField = (Core.Name "operator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryOperatorDeclarator"),
              Core.projectionField = (Core.Name "left")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryOperatorDeclarator"),
              Core.projectionField = (Core.Name "right")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

binaryRelationalExpression :: Phantoms.TTerm Syntax.RelationalExpression -> Phantoms.TTerm Syntax.RelationalOperator -> Phantoms.TTerm Syntax.ShiftExpression -> Phantoms.TTerm Syntax.BinaryRelationalExpression
binaryRelationalExpression left operator right =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryRelationalExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Phantoms.unTTerm left)},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Phantoms.unTTerm operator)},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Phantoms.unTTerm right)}]}))

binaryRelationalExpressionLeft :: Phantoms.TTerm Syntax.BinaryRelationalExpression -> Phantoms.TTerm Syntax.RelationalExpression
binaryRelationalExpressionLeft x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryRelationalExpression"),
        Core.projectionField = (Core.Name "left")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

binaryRelationalExpressionOperator :: Phantoms.TTerm Syntax.BinaryRelationalExpression -> Phantoms.TTerm Syntax.RelationalOperator
binaryRelationalExpressionOperator x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryRelationalExpression"),
        Core.projectionField = (Core.Name "operator")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

binaryRelationalExpressionRight :: Phantoms.TTerm Syntax.BinaryRelationalExpression -> Phantoms.TTerm Syntax.ShiftExpression
binaryRelationalExpressionRight x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryRelationalExpression"),
        Core.projectionField = (Core.Name "right")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

binaryRelationalExpressionWithLeft :: Phantoms.TTerm Syntax.BinaryRelationalExpression -> Phantoms.TTerm Syntax.RelationalExpression -> Phantoms.TTerm Syntax.BinaryRelationalExpression
binaryRelationalExpressionWithLeft original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryRelationalExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryRelationalExpression"),
              Core.projectionField = (Core.Name "operator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryRelationalExpression"),
              Core.projectionField = (Core.Name "right")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

binaryRelationalExpressionWithOperator :: Phantoms.TTerm Syntax.BinaryRelationalExpression -> Phantoms.TTerm Syntax.RelationalOperator -> Phantoms.TTerm Syntax.BinaryRelationalExpression
binaryRelationalExpressionWithOperator original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryRelationalExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryRelationalExpression"),
              Core.projectionField = (Core.Name "left")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryRelationalExpression"),
              Core.projectionField = (Core.Name "right")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

binaryRelationalExpressionWithRight :: Phantoms.TTerm Syntax.BinaryRelationalExpression -> Phantoms.TTerm Syntax.ShiftExpression -> Phantoms.TTerm Syntax.BinaryRelationalExpression
binaryRelationalExpressionWithRight original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryRelationalExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryRelationalExpression"),
              Core.projectionField = (Core.Name "left")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryRelationalExpression"),
              Core.projectionField = (Core.Name "operator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

binaryShiftExpression :: Phantoms.TTerm Syntax.ShiftExpression -> Phantoms.TTerm Syntax.ShiftOperator -> Phantoms.TTerm Syntax.AdditiveExpression -> Phantoms.TTerm Syntax.BinaryShiftExpression
binaryShiftExpression left operator right =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryShiftExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Phantoms.unTTerm left)},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Phantoms.unTTerm operator)},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Phantoms.unTTerm right)}]}))

binaryShiftExpressionLeft :: Phantoms.TTerm Syntax.BinaryShiftExpression -> Phantoms.TTerm Syntax.ShiftExpression
binaryShiftExpressionLeft x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryShiftExpression"),
        Core.projectionField = (Core.Name "left")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

binaryShiftExpressionOperator :: Phantoms.TTerm Syntax.BinaryShiftExpression -> Phantoms.TTerm Syntax.ShiftOperator
binaryShiftExpressionOperator x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryShiftExpression"),
        Core.projectionField = (Core.Name "operator")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

binaryShiftExpressionRight :: Phantoms.TTerm Syntax.BinaryShiftExpression -> Phantoms.TTerm Syntax.AdditiveExpression
binaryShiftExpressionRight x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryShiftExpression"),
        Core.projectionField = (Core.Name "right")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

binaryShiftExpressionWithLeft :: Phantoms.TTerm Syntax.BinaryShiftExpression -> Phantoms.TTerm Syntax.ShiftExpression -> Phantoms.TTerm Syntax.BinaryShiftExpression
binaryShiftExpressionWithLeft original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryShiftExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryShiftExpression"),
              Core.projectionField = (Core.Name "operator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryShiftExpression"),
              Core.projectionField = (Core.Name "right")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

binaryShiftExpressionWithOperator :: Phantoms.TTerm Syntax.BinaryShiftExpression -> Phantoms.TTerm Syntax.ShiftOperator -> Phantoms.TTerm Syntax.BinaryShiftExpression
binaryShiftExpressionWithOperator original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryShiftExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryShiftExpression"),
              Core.projectionField = (Core.Name "left")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryShiftExpression"),
              Core.projectionField = (Core.Name "right")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

binaryShiftExpressionWithRight :: Phantoms.TTerm Syntax.BinaryShiftExpression -> Phantoms.TTerm Syntax.AdditiveExpression -> Phantoms.TTerm Syntax.BinaryShiftExpression
binaryShiftExpressionWithRight original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BinaryShiftExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryShiftExpression"),
              Core.projectionField = (Core.Name "left")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BinaryShiftExpression"),
              Core.projectionField = (Core.Name "operator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

block :: Phantoms.TTerm [Syntax.Statement] -> Phantoms.TTerm Syntax.Block
block x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.Block"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

blockPropertyBody :: Phantoms.TTerm Syntax.AccessorDeclarations -> Phantoms.TTerm (Maybe Syntax.VariableInitializer) -> Phantoms.TTerm Syntax.BlockPropertyBody
blockPropertyBody accessors initializer =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BlockPropertyBody"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "accessors"),
          Core.fieldTerm = (Phantoms.unTTerm accessors)},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Phantoms.unTTerm initializer)}]}))

blockPropertyBodyAccessors :: Phantoms.TTerm Syntax.BlockPropertyBody -> Phantoms.TTerm Syntax.AccessorDeclarations
blockPropertyBodyAccessors x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BlockPropertyBody"),
        Core.projectionField = (Core.Name "accessors")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

blockPropertyBodyInitializer :: Phantoms.TTerm Syntax.BlockPropertyBody -> Phantoms.TTerm (Maybe Syntax.VariableInitializer)
blockPropertyBodyInitializer x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BlockPropertyBody"),
        Core.projectionField = (Core.Name "initializer")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

blockPropertyBodyWithAccessors :: Phantoms.TTerm Syntax.BlockPropertyBody -> Phantoms.TTerm Syntax.AccessorDeclarations -> Phantoms.TTerm Syntax.BlockPropertyBody
blockPropertyBodyWithAccessors original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BlockPropertyBody"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "accessors"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BlockPropertyBody"),
              Core.projectionField = (Core.Name "initializer")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

blockPropertyBodyWithInitializer :: Phantoms.TTerm Syntax.BlockPropertyBody -> Phantoms.TTerm (Maybe Syntax.VariableInitializer) -> Phantoms.TTerm Syntax.BlockPropertyBody
blockPropertyBodyWithInitializer original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.BlockPropertyBody"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "accessors"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.BlockPropertyBody"),
              Core.projectionField = (Core.Name "accessors")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

booleanExpression :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.BooleanExpression
booleanExpression x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.BooleanExpression"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

castExpression :: Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.UnaryExpression -> Phantoms.TTerm Syntax.CastExpression
castExpression type_ expression =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.CastExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm expression)}]}))

castExpressionExpression :: Phantoms.TTerm Syntax.CastExpression -> Phantoms.TTerm Syntax.UnaryExpression
castExpressionExpression x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.CastExpression"),
        Core.projectionField = (Core.Name "expression")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

castExpressionType :: Phantoms.TTerm Syntax.CastExpression -> Phantoms.TTerm Syntax.Type
castExpressionType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.CastExpression"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

castExpressionWithExpression :: Phantoms.TTerm Syntax.CastExpression -> Phantoms.TTerm Syntax.UnaryExpression -> Phantoms.TTerm Syntax.CastExpression
castExpressionWithExpression original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.CastExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.CastExpression"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

castExpressionWithType :: Phantoms.TTerm Syntax.CastExpression -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.CastExpression
castExpressionWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.CastExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.CastExpression"),
              Core.projectionField = (Core.Name "expression")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

catchClausesGeneral :: Phantoms.TTerm Syntax.Block -> Phantoms.TTerm Syntax.CatchClauses
catchClausesGeneral x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.CatchClauses"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "general"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

catchClausesSpecific :: Phantoms.TTerm [Syntax.SpecificCatchClause] -> Phantoms.TTerm Syntax.CatchClauses
catchClausesSpecific x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.CatchClauses"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "specific"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

classBaseClass :: Phantoms.TTerm (Maybe Syntax.ClassType) -> Phantoms.TTerm Syntax.ClassBase
classBaseClass x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ClassBase"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "class"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

classBaseInterfaces :: Phantoms.TTerm [Syntax.InterfaceType] -> Phantoms.TTerm Syntax.ClassBase
classBaseInterfaces x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ClassBase"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "interfaces"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

classBody :: Phantoms.TTerm [Syntax.ClassMemberDeclaration] -> Phantoms.TTerm Syntax.ClassBody
classBody x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.ClassBody"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

classDeclaration :: Phantoms.TTerm [Syntax.AttributeSection] -> Phantoms.TTerm [Syntax.ClassModifier] -> Phantoms.TTerm Bool -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm (Maybe Syntax.TypeParameterList) -> Phantoms.TTerm (Maybe Syntax.ClassBase) -> Phantoms.TTerm [Syntax.TypeParameterConstraintsClause] -> Phantoms.TTerm Syntax.ClassBody -> Phantoms.TTerm Syntax.ClassDeclaration
classDeclaration attributes modifiers partial name parameters base constraints body =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm modifiers)},
        Core.Field {
          Core.fieldName = (Core.Name "partial"),
          Core.fieldTerm = (Phantoms.unTTerm partial)},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm name)},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Phantoms.unTTerm parameters)},
        Core.Field {
          Core.fieldName = (Core.Name "base"),
          Core.fieldTerm = (Phantoms.unTTerm base)},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Phantoms.unTTerm constraints)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)}]}))

classDeclarationAttributes :: Phantoms.TTerm Syntax.ClassDeclaration -> Phantoms.TTerm [Syntax.AttributeSection]
classDeclarationAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

classDeclarationBase :: Phantoms.TTerm Syntax.ClassDeclaration -> Phantoms.TTerm (Maybe Syntax.ClassBase)
classDeclarationBase x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
        Core.projectionField = (Core.Name "base")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

classDeclarationBody :: Phantoms.TTerm Syntax.ClassDeclaration -> Phantoms.TTerm Syntax.ClassBody
classDeclarationBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

classDeclarationConstraints :: Phantoms.TTerm Syntax.ClassDeclaration -> Phantoms.TTerm [Syntax.TypeParameterConstraintsClause]
classDeclarationConstraints x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
        Core.projectionField = (Core.Name "constraints")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

classDeclarationModifiers :: Phantoms.TTerm Syntax.ClassDeclaration -> Phantoms.TTerm [Syntax.ClassModifier]
classDeclarationModifiers x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
        Core.projectionField = (Core.Name "modifiers")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

classDeclarationName :: Phantoms.TTerm Syntax.ClassDeclaration -> Phantoms.TTerm Syntax.Identifier
classDeclarationName x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
        Core.projectionField = (Core.Name "name")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

classDeclarationParameters :: Phantoms.TTerm Syntax.ClassDeclaration -> Phantoms.TTerm (Maybe Syntax.TypeParameterList)
classDeclarationParameters x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
        Core.projectionField = (Core.Name "parameters")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

classDeclarationPartial :: Phantoms.TTerm Syntax.ClassDeclaration -> Phantoms.TTerm Bool
classDeclarationPartial x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
        Core.projectionField = (Core.Name "partial")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

classDeclarationWithAttributes :: Phantoms.TTerm Syntax.ClassDeclaration -> Phantoms.TTerm [Syntax.AttributeSection] -> Phantoms.TTerm Syntax.ClassDeclaration
classDeclarationWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "partial"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "partial")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "base"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "base")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

classDeclarationWithBase :: Phantoms.TTerm Syntax.ClassDeclaration -> Phantoms.TTerm (Maybe Syntax.ClassBase) -> Phantoms.TTerm Syntax.ClassDeclaration
classDeclarationWithBase original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "partial"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "partial")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "base"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

classDeclarationWithBody :: Phantoms.TTerm Syntax.ClassDeclaration -> Phantoms.TTerm Syntax.ClassBody -> Phantoms.TTerm Syntax.ClassDeclaration
classDeclarationWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "partial"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "partial")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "base"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "base")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

classDeclarationWithConstraints :: Phantoms.TTerm Syntax.ClassDeclaration -> Phantoms.TTerm [Syntax.TypeParameterConstraintsClause] -> Phantoms.TTerm Syntax.ClassDeclaration
classDeclarationWithConstraints original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "partial"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "partial")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "base"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "base")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

classDeclarationWithModifiers :: Phantoms.TTerm Syntax.ClassDeclaration -> Phantoms.TTerm [Syntax.ClassModifier] -> Phantoms.TTerm Syntax.ClassDeclaration
classDeclarationWithModifiers original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "partial"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "partial")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "base"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "base")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

classDeclarationWithName :: Phantoms.TTerm Syntax.ClassDeclaration -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.ClassDeclaration
classDeclarationWithName original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "partial"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "partial")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "base"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "base")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

classDeclarationWithParameters :: Phantoms.TTerm Syntax.ClassDeclaration -> Phantoms.TTerm (Maybe Syntax.TypeParameterList) -> Phantoms.TTerm Syntax.ClassDeclaration
classDeclarationWithParameters original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "partial"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "partial")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "base"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "base")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

classDeclarationWithPartial :: Phantoms.TTerm Syntax.ClassDeclaration -> Phantoms.TTerm Bool -> Phantoms.TTerm Syntax.ClassDeclaration
classDeclarationWithPartial original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "partial"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "base"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "base")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ClassDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

classMemberDeclarationConstant :: Phantoms.TTerm Syntax.ConstantDeclaration -> Phantoms.TTerm Syntax.ClassMemberDeclaration
classMemberDeclarationConstant x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ClassMemberDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "constant"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

classMemberDeclarationConstructor :: Phantoms.TTerm Syntax.ConstructorDeclaration -> Phantoms.TTerm Syntax.ClassMemberDeclaration
classMemberDeclarationConstructor x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ClassMemberDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "constructor"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

classMemberDeclarationEvent :: Phantoms.TTerm Syntax.EventDeclaration -> Phantoms.TTerm Syntax.ClassMemberDeclaration
classMemberDeclarationEvent x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ClassMemberDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "event"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

classMemberDeclarationField :: Phantoms.TTerm Syntax.FieldDeclaration -> Phantoms.TTerm Syntax.ClassMemberDeclaration
classMemberDeclarationField x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ClassMemberDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "field"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

classMemberDeclarationFinalizer :: Phantoms.TTerm Syntax.FinalizerDeclaration -> Phantoms.TTerm Syntax.ClassMemberDeclaration
classMemberDeclarationFinalizer x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ClassMemberDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "finalizer"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

classMemberDeclarationIndexer :: Phantoms.TTerm Syntax.IndexerDeclaration -> Phantoms.TTerm Syntax.ClassMemberDeclaration
classMemberDeclarationIndexer x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ClassMemberDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "indexer"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

classMemberDeclarationMethod :: Phantoms.TTerm Syntax.MethodDeclaration -> Phantoms.TTerm Syntax.ClassMemberDeclaration
classMemberDeclarationMethod x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ClassMemberDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "method"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

classMemberDeclarationOperator :: Phantoms.TTerm Syntax.OperatorDeclaration -> Phantoms.TTerm Syntax.ClassMemberDeclaration
classMemberDeclarationOperator x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ClassMemberDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "operator"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

classMemberDeclarationProperty :: Phantoms.TTerm Syntax.PropertyDeclaration -> Phantoms.TTerm Syntax.ClassMemberDeclaration
classMemberDeclarationProperty x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ClassMemberDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "property"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

classMemberDeclarationStaticConstructor :: Phantoms.TTerm Syntax.StaticConstructorDeclaration -> Phantoms.TTerm Syntax.ClassMemberDeclaration
classMemberDeclarationStaticConstructor x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ClassMemberDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "staticConstructor"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

classMemberDeclarationType :: Phantoms.TTerm Syntax.TypeDeclaration -> Phantoms.TTerm Syntax.ClassMemberDeclaration
classMemberDeclarationType x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ClassMemberDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "type"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

classModifierAbstract :: Phantoms.TTerm Syntax.ClassModifier
classModifierAbstract =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ClassModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "abstract"),
        Core.fieldTerm = Core.TermUnit}}))

classModifierInternal :: Phantoms.TTerm Syntax.ClassModifier
classModifierInternal =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ClassModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "internal"),
        Core.fieldTerm = Core.TermUnit}}))

classModifierNew :: Phantoms.TTerm Syntax.ClassModifier
classModifierNew =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ClassModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "new"),
        Core.fieldTerm = Core.TermUnit}}))

classModifierPrivate :: Phantoms.TTerm Syntax.ClassModifier
classModifierPrivate =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ClassModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "private"),
        Core.fieldTerm = Core.TermUnit}}))

classModifierProtected :: Phantoms.TTerm Syntax.ClassModifier
classModifierProtected =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ClassModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "protected"),
        Core.fieldTerm = Core.TermUnit}}))

classModifierPublic :: Phantoms.TTerm Syntax.ClassModifier
classModifierPublic =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ClassModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "public"),
        Core.fieldTerm = Core.TermUnit}}))

classModifierSealed :: Phantoms.TTerm Syntax.ClassModifier
classModifierSealed =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ClassModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "sealed"),
        Core.fieldTerm = Core.TermUnit}}))

classModifierStatic :: Phantoms.TTerm Syntax.ClassModifier
classModifierStatic =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ClassModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "static"),
        Core.fieldTerm = Core.TermUnit}}))

classModifierUnsafe :: Phantoms.TTerm Syntax.ClassModifier
classModifierUnsafe =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ClassModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "unsafe"),
        Core.fieldTerm = Core.TermUnit}}))

classTypeObject :: Phantoms.TTerm Syntax.ClassType
classTypeObject =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ClassType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "object"),
        Core.fieldTerm = Core.TermUnit}}))

classTypeString :: Phantoms.TTerm Syntax.ClassType
classTypeString =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ClassType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "string"),
        Core.fieldTerm = Core.TermUnit}}))

classTypeTypeName :: Phantoms.TTerm Syntax.TypeName -> Phantoms.TTerm Syntax.ClassType
classTypeTypeName x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ClassType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "typeName"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

compilationUnit :: Phantoms.TTerm [Syntax.ExternAliasDirective] -> Phantoms.TTerm [Syntax.UsingDirective] -> Phantoms.TTerm [Syntax.GlobalAttributeSection] -> Phantoms.TTerm [Syntax.NamespaceMemberDeclaration] -> Phantoms.TTerm Syntax.CompilationUnit
compilationUnit externs usings attributes members =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.CompilationUnit"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "externs"),
          Core.fieldTerm = (Phantoms.unTTerm externs)},
        Core.Field {
          Core.fieldName = (Core.Name "usings"),
          Core.fieldTerm = (Phantoms.unTTerm usings)},
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "members"),
          Core.fieldTerm = (Phantoms.unTTerm members)}]}))

compilationUnitAttributes :: Phantoms.TTerm Syntax.CompilationUnit -> Phantoms.TTerm [Syntax.GlobalAttributeSection]
compilationUnitAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.CompilationUnit"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

compilationUnitExterns :: Phantoms.TTerm Syntax.CompilationUnit -> Phantoms.TTerm [Syntax.ExternAliasDirective]
compilationUnitExterns x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.CompilationUnit"),
        Core.projectionField = (Core.Name "externs")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

compilationUnitMembers :: Phantoms.TTerm Syntax.CompilationUnit -> Phantoms.TTerm [Syntax.NamespaceMemberDeclaration]
compilationUnitMembers x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.CompilationUnit"),
        Core.projectionField = (Core.Name "members")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

compilationUnitUsings :: Phantoms.TTerm Syntax.CompilationUnit -> Phantoms.TTerm [Syntax.UsingDirective]
compilationUnitUsings x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.CompilationUnit"),
        Core.projectionField = (Core.Name "usings")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

compilationUnitWithAttributes :: Phantoms.TTerm Syntax.CompilationUnit -> Phantoms.TTerm [Syntax.GlobalAttributeSection] -> Phantoms.TTerm Syntax.CompilationUnit
compilationUnitWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.CompilationUnit"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "externs"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.CompilationUnit"),
              Core.projectionField = (Core.Name "externs")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "usings"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.CompilationUnit"),
              Core.projectionField = (Core.Name "usings")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "members"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.CompilationUnit"),
              Core.projectionField = (Core.Name "members")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

compilationUnitWithExterns :: Phantoms.TTerm Syntax.CompilationUnit -> Phantoms.TTerm [Syntax.ExternAliasDirective] -> Phantoms.TTerm Syntax.CompilationUnit
compilationUnitWithExterns original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.CompilationUnit"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "externs"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "usings"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.CompilationUnit"),
              Core.projectionField = (Core.Name "usings")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.CompilationUnit"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "members"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.CompilationUnit"),
              Core.projectionField = (Core.Name "members")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

compilationUnitWithMembers :: Phantoms.TTerm Syntax.CompilationUnit -> Phantoms.TTerm [Syntax.NamespaceMemberDeclaration] -> Phantoms.TTerm Syntax.CompilationUnit
compilationUnitWithMembers original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.CompilationUnit"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "externs"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.CompilationUnit"),
              Core.projectionField = (Core.Name "externs")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "usings"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.CompilationUnit"),
              Core.projectionField = (Core.Name "usings")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.CompilationUnit"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "members"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

compilationUnitWithUsings :: Phantoms.TTerm Syntax.CompilationUnit -> Phantoms.TTerm [Syntax.UsingDirective] -> Phantoms.TTerm Syntax.CompilationUnit
compilationUnitWithUsings original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.CompilationUnit"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "externs"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.CompilationUnit"),
              Core.projectionField = (Core.Name "externs")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "usings"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.CompilationUnit"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "members"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.CompilationUnit"),
              Core.projectionField = (Core.Name "members")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

conditionalAndExpressionBinary :: Phantoms.TTerm Syntax.BinaryConditionalAndExpression -> Phantoms.TTerm Syntax.ConditionalAndExpression
conditionalAndExpressionBinary x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ConditionalAndExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "binary"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

conditionalAndExpressionSimple :: Phantoms.TTerm Syntax.InclusiveOrExpression -> Phantoms.TTerm Syntax.ConditionalAndExpression
conditionalAndExpressionSimple x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ConditionalAndExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "simple"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

conditionalExpressionRefConditional :: Phantoms.TTerm Syntax.RefConditionalExpression -> Phantoms.TTerm Syntax.ConditionalExpression
conditionalExpressionRefConditional x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ConditionalExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "refConditional"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

conditionalExpressionSimple :: Phantoms.TTerm Syntax.NullCoalescingExpression -> Phantoms.TTerm Syntax.ConditionalExpression
conditionalExpressionSimple x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ConditionalExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "simple"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

conditionalExpressionSimpleConditional :: Phantoms.TTerm Syntax.SimpleConditionalExpression -> Phantoms.TTerm Syntax.ConditionalExpression
conditionalExpressionSimpleConditional x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ConditionalExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "simpleConditional"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

conditionalOrExpressionBinary :: Phantoms.TTerm Syntax.BinaryConditionalOrExpression -> Phantoms.TTerm Syntax.ConditionalOrExpression
conditionalOrExpressionBinary x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ConditionalOrExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "binary"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

conditionalOrExpressionSimple :: Phantoms.TTerm Syntax.ConditionalAndExpression -> Phantoms.TTerm Syntax.ConditionalOrExpression
conditionalOrExpressionSimple x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ConditionalOrExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "simple"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

constantDeclaration :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm [Syntax.ConstantModifier] -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm [Syntax.ConstantDeclarator] -> Phantoms.TTerm Syntax.ConstantDeclaration
constantDeclaration attributes modifiers type_ declarators =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ConstantDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm modifiers)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Phantoms.unTTerm declarators)}]}))

constantDeclarationAttributes :: Phantoms.TTerm Syntax.ConstantDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes)
constantDeclarationAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstantDeclaration"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

constantDeclarationDeclarators :: Phantoms.TTerm Syntax.ConstantDeclaration -> Phantoms.TTerm [Syntax.ConstantDeclarator]
constantDeclarationDeclarators x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstantDeclaration"),
        Core.projectionField = (Core.Name "declarators")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

constantDeclarationModifiers :: Phantoms.TTerm Syntax.ConstantDeclaration -> Phantoms.TTerm [Syntax.ConstantModifier]
constantDeclarationModifiers x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstantDeclaration"),
        Core.projectionField = (Core.Name "modifiers")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

constantDeclarationType :: Phantoms.TTerm Syntax.ConstantDeclaration -> Phantoms.TTerm Syntax.Type
constantDeclarationType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstantDeclaration"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

constantDeclarationWithAttributes :: Phantoms.TTerm Syntax.ConstantDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.ConstantDeclaration
constantDeclarationWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ConstantDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstantDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstantDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstantDeclaration"),
              Core.projectionField = (Core.Name "declarators")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

constantDeclarationWithDeclarators :: Phantoms.TTerm Syntax.ConstantDeclaration -> Phantoms.TTerm [Syntax.ConstantDeclarator] -> Phantoms.TTerm Syntax.ConstantDeclaration
constantDeclarationWithDeclarators original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ConstantDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstantDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstantDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstantDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

constantDeclarationWithModifiers :: Phantoms.TTerm Syntax.ConstantDeclaration -> Phantoms.TTerm [Syntax.ConstantModifier] -> Phantoms.TTerm Syntax.ConstantDeclaration
constantDeclarationWithModifiers original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ConstantDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstantDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstantDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstantDeclaration"),
              Core.projectionField = (Core.Name "declarators")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

constantDeclarationWithType :: Phantoms.TTerm Syntax.ConstantDeclaration -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.ConstantDeclaration
constantDeclarationWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ConstantDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstantDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstantDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstantDeclaration"),
              Core.projectionField = (Core.Name "declarators")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

constantDeclarator :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.ConstantExpression -> Phantoms.TTerm Syntax.ConstantDeclarator
constantDeclarator identifier expression =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ConstantDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm identifier)},
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm expression)}]}))

constantDeclaratorExpression :: Phantoms.TTerm Syntax.ConstantDeclarator -> Phantoms.TTerm Syntax.ConstantExpression
constantDeclaratorExpression x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstantDeclarator"),
        Core.projectionField = (Core.Name "expression")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

constantDeclaratorIdentifier :: Phantoms.TTerm Syntax.ConstantDeclarator -> Phantoms.TTerm Syntax.Identifier
constantDeclaratorIdentifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstantDeclarator"),
        Core.projectionField = (Core.Name "identifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

constantDeclaratorWithExpression :: Phantoms.TTerm Syntax.ConstantDeclarator -> Phantoms.TTerm Syntax.ConstantExpression -> Phantoms.TTerm Syntax.ConstantDeclarator
constantDeclaratorWithExpression original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ConstantDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstantDeclarator"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

constantDeclaratorWithIdentifier :: Phantoms.TTerm Syntax.ConstantDeclarator -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.ConstantDeclarator
constantDeclaratorWithIdentifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ConstantDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstantDeclarator"),
              Core.projectionField = (Core.Name "expression")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

constantExpression :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.ConstantExpression
constantExpression x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.ConstantExpression"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

constantModifierInternal :: Phantoms.TTerm Syntax.ConstantModifier
constantModifierInternal =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ConstantModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "internal"),
        Core.fieldTerm = Core.TermUnit}}))

constantModifierNew :: Phantoms.TTerm Syntax.ConstantModifier
constantModifierNew =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ConstantModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "new"),
        Core.fieldTerm = Core.TermUnit}}))

constantModifierPrivate :: Phantoms.TTerm Syntax.ConstantModifier
constantModifierPrivate =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ConstantModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "private"),
        Core.fieldTerm = Core.TermUnit}}))

constantModifierProtected :: Phantoms.TTerm Syntax.ConstantModifier
constantModifierProtected =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ConstantModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "protected"),
        Core.fieldTerm = Core.TermUnit}}))

constantModifierPublic :: Phantoms.TTerm Syntax.ConstantModifier
constantModifierPublic =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ConstantModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "public"),
        Core.fieldTerm = Core.TermUnit}}))

constructorBodyBlock :: Phantoms.TTerm Syntax.Block -> Phantoms.TTerm Syntax.ConstructorBody
constructorBodyBlock x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "block"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

constructorBodyEmpty :: Phantoms.TTerm Syntax.ConstructorBody
constructorBodyEmpty =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "empty"),
        Core.fieldTerm = Core.TermUnit}}))

constructorBodyExpression :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.ConstructorBody
constructorBodyExpression x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "expression"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

constructorDeclaration :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm [Syntax.ConstructorModifier] -> Phantoms.TTerm Syntax.ConstructorDeclarator -> Phantoms.TTerm Syntax.ConstructorBody -> Phantoms.TTerm Syntax.ConstructorDeclaration
constructorDeclaration attributes modifiers declarator body =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm modifiers)},
        Core.Field {
          Core.fieldName = (Core.Name "declarator"),
          Core.fieldTerm = (Phantoms.unTTerm declarator)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)}]}))

constructorDeclarationAttributes :: Phantoms.TTerm Syntax.ConstructorDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes)
constructorDeclarationAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclaration"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

constructorDeclarationBody :: Phantoms.TTerm Syntax.ConstructorDeclaration -> Phantoms.TTerm Syntax.ConstructorBody
constructorDeclarationBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclaration"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

constructorDeclarationDeclarator :: Phantoms.TTerm Syntax.ConstructorDeclaration -> Phantoms.TTerm Syntax.ConstructorDeclarator
constructorDeclarationDeclarator x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclaration"),
        Core.projectionField = (Core.Name "declarator")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

constructorDeclarationModifiers :: Phantoms.TTerm Syntax.ConstructorDeclaration -> Phantoms.TTerm [Syntax.ConstructorModifier]
constructorDeclarationModifiers x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclaration"),
        Core.projectionField = (Core.Name "modifiers")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

constructorDeclarationWithAttributes :: Phantoms.TTerm Syntax.ConstructorDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.ConstructorDeclaration
constructorDeclarationWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclaration"),
              Core.projectionField = (Core.Name "declarator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

constructorDeclarationWithBody :: Phantoms.TTerm Syntax.ConstructorDeclaration -> Phantoms.TTerm Syntax.ConstructorBody -> Phantoms.TTerm Syntax.ConstructorDeclaration
constructorDeclarationWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclaration"),
              Core.projectionField = (Core.Name "declarator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

constructorDeclarationWithDeclarator :: Phantoms.TTerm Syntax.ConstructorDeclaration -> Phantoms.TTerm Syntax.ConstructorDeclarator -> Phantoms.TTerm Syntax.ConstructorDeclaration
constructorDeclarationWithDeclarator original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarator"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

constructorDeclarationWithModifiers :: Phantoms.TTerm Syntax.ConstructorDeclaration -> Phantoms.TTerm [Syntax.ConstructorModifier] -> Phantoms.TTerm Syntax.ConstructorDeclaration
constructorDeclarationWithModifiers original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "declarator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclaration"),
              Core.projectionField = (Core.Name "declarator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

constructorDeclarator :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm (Maybe Syntax.FormalParameterList) -> Phantoms.TTerm (Maybe Syntax.ConstructorInitializer) -> Phantoms.TTerm Syntax.ConstructorDeclarator
constructorDeclarator name parameters initializer =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm name)},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Phantoms.unTTerm parameters)},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Phantoms.unTTerm initializer)}]}))

constructorDeclaratorInitializer :: Phantoms.TTerm Syntax.ConstructorDeclarator -> Phantoms.TTerm (Maybe Syntax.ConstructorInitializer)
constructorDeclaratorInitializer x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclarator"),
        Core.projectionField = (Core.Name "initializer")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

constructorDeclaratorName :: Phantoms.TTerm Syntax.ConstructorDeclarator -> Phantoms.TTerm Syntax.Identifier
constructorDeclaratorName x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclarator"),
        Core.projectionField = (Core.Name "name")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

constructorDeclaratorParameters :: Phantoms.TTerm Syntax.ConstructorDeclarator -> Phantoms.TTerm (Maybe Syntax.FormalParameterList)
constructorDeclaratorParameters x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclarator"),
        Core.projectionField = (Core.Name "parameters")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

constructorDeclaratorWithInitializer :: Phantoms.TTerm Syntax.ConstructorDeclarator -> Phantoms.TTerm (Maybe Syntax.ConstructorInitializer) -> Phantoms.TTerm Syntax.ConstructorDeclarator
constructorDeclaratorWithInitializer original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclarator"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclarator"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

constructorDeclaratorWithName :: Phantoms.TTerm Syntax.ConstructorDeclarator -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.ConstructorDeclarator
constructorDeclaratorWithName original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclarator"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclarator"),
              Core.projectionField = (Core.Name "initializer")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

constructorDeclaratorWithParameters :: Phantoms.TTerm Syntax.ConstructorDeclarator -> Phantoms.TTerm (Maybe Syntax.FormalParameterList) -> Phantoms.TTerm Syntax.ConstructorDeclarator
constructorDeclaratorWithParameters original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclarator"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorDeclarator"),
              Core.projectionField = (Core.Name "initializer")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

constructorInitializerBase :: Phantoms.TTerm (Maybe Syntax.ArgumentList) -> Phantoms.TTerm Syntax.ConstructorInitializer
constructorInitializerBase x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorInitializer"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "base"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

constructorInitializerThis :: Phantoms.TTerm (Maybe Syntax.ArgumentList) -> Phantoms.TTerm Syntax.ConstructorInitializer
constructorInitializerThis x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorInitializer"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "this"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

constructorModifierExtern :: Phantoms.TTerm Syntax.ConstructorModifier
constructorModifierExtern =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "extern"),
        Core.fieldTerm = Core.TermUnit}}))

constructorModifierInternal :: Phantoms.TTerm Syntax.ConstructorModifier
constructorModifierInternal =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "internal"),
        Core.fieldTerm = Core.TermUnit}}))

constructorModifierPrivate :: Phantoms.TTerm Syntax.ConstructorModifier
constructorModifierPrivate =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "private"),
        Core.fieldTerm = Core.TermUnit}}))

constructorModifierProtected :: Phantoms.TTerm Syntax.ConstructorModifier
constructorModifierProtected =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "protected"),
        Core.fieldTerm = Core.TermUnit}}))

constructorModifierPublic :: Phantoms.TTerm Syntax.ConstructorModifier
constructorModifierPublic =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "public"),
        Core.fieldTerm = Core.TermUnit}}))

constructorModifierUnsafe :: Phantoms.TTerm Syntax.ConstructorModifier
constructorModifierUnsafe =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ConstructorModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "unsafe"),
        Core.fieldTerm = Core.TermUnit}}))

conversionKindExplicit :: Phantoms.TTerm Syntax.ConversionKind
conversionKindExplicit =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ConversionKind"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "explicit"),
        Core.fieldTerm = Core.TermUnit}}))

conversionKindImplicit :: Phantoms.TTerm Syntax.ConversionKind
conversionKindImplicit =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ConversionKind"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "implicit"),
        Core.fieldTerm = Core.TermUnit}}))

conversionOperatorDeclarator :: Phantoms.TTerm Syntax.ConversionKind -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.FixedParameter -> Phantoms.TTerm Syntax.ConversionOperatorDeclarator
conversionOperatorDeclarator kind type_ parameter =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ConversionOperatorDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "kind"),
          Core.fieldTerm = (Phantoms.unTTerm kind)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "parameter"),
          Core.fieldTerm = (Phantoms.unTTerm parameter)}]}))

conversionOperatorDeclaratorKind :: Phantoms.TTerm Syntax.ConversionOperatorDeclarator -> Phantoms.TTerm Syntax.ConversionKind
conversionOperatorDeclaratorKind x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConversionOperatorDeclarator"),
        Core.projectionField = (Core.Name "kind")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

conversionOperatorDeclaratorParameter :: Phantoms.TTerm Syntax.ConversionOperatorDeclarator -> Phantoms.TTerm Syntax.FixedParameter
conversionOperatorDeclaratorParameter x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConversionOperatorDeclarator"),
        Core.projectionField = (Core.Name "parameter")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

conversionOperatorDeclaratorType :: Phantoms.TTerm Syntax.ConversionOperatorDeclarator -> Phantoms.TTerm Syntax.Type
conversionOperatorDeclaratorType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConversionOperatorDeclarator"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

conversionOperatorDeclaratorWithKind :: Phantoms.TTerm Syntax.ConversionOperatorDeclarator -> Phantoms.TTerm Syntax.ConversionKind -> Phantoms.TTerm Syntax.ConversionOperatorDeclarator
conversionOperatorDeclaratorWithKind original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ConversionOperatorDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "kind"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConversionOperatorDeclarator"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameter"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConversionOperatorDeclarator"),
              Core.projectionField = (Core.Name "parameter")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

conversionOperatorDeclaratorWithParameter :: Phantoms.TTerm Syntax.ConversionOperatorDeclarator -> Phantoms.TTerm Syntax.FixedParameter -> Phantoms.TTerm Syntax.ConversionOperatorDeclarator
conversionOperatorDeclaratorWithParameter original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ConversionOperatorDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "kind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConversionOperatorDeclarator"),
              Core.projectionField = (Core.Name "kind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConversionOperatorDeclarator"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameter"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

conversionOperatorDeclaratorWithType :: Phantoms.TTerm Syntax.ConversionOperatorDeclarator -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.ConversionOperatorDeclarator
conversionOperatorDeclaratorWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ConversionOperatorDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "kind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConversionOperatorDeclarator"),
              Core.projectionField = (Core.Name "kind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "parameter"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ConversionOperatorDeclarator"),
              Core.projectionField = (Core.Name "parameter")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

declarationExpression :: Phantoms.TTerm Syntax.LocalVariableType -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.DeclarationExpression
declarationExpression type_ identifier =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.DeclarationExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm identifier)}]}))

declarationExpressionIdentifier :: Phantoms.TTerm Syntax.DeclarationExpression -> Phantoms.TTerm Syntax.Identifier
declarationExpressionIdentifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DeclarationExpression"),
        Core.projectionField = (Core.Name "identifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

declarationExpressionType :: Phantoms.TTerm Syntax.DeclarationExpression -> Phantoms.TTerm Syntax.LocalVariableType
declarationExpressionType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DeclarationExpression"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

declarationExpressionWithIdentifier :: Phantoms.TTerm Syntax.DeclarationExpression -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.DeclarationExpression
declarationExpressionWithIdentifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.DeclarationExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DeclarationExpression"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

declarationExpressionWithType :: Phantoms.TTerm Syntax.DeclarationExpression -> Phantoms.TTerm Syntax.LocalVariableType -> Phantoms.TTerm Syntax.DeclarationExpression
declarationExpressionWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.DeclarationExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DeclarationExpression"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

declarationPattern :: Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.Designation -> Phantoms.TTerm Syntax.DeclarationPattern
declarationPattern type_ designation =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.DeclarationPattern"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "designation"),
          Core.fieldTerm = (Phantoms.unTTerm designation)}]}))

declarationPatternDesignation :: Phantoms.TTerm Syntax.DeclarationPattern -> Phantoms.TTerm Syntax.Designation
declarationPatternDesignation x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DeclarationPattern"),
        Core.projectionField = (Core.Name "designation")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

declarationPatternType :: Phantoms.TTerm Syntax.DeclarationPattern -> Phantoms.TTerm Syntax.Type
declarationPatternType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DeclarationPattern"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

declarationPatternWithDesignation :: Phantoms.TTerm Syntax.DeclarationPattern -> Phantoms.TTerm Syntax.Designation -> Phantoms.TTerm Syntax.DeclarationPattern
declarationPatternWithDesignation original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.DeclarationPattern"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DeclarationPattern"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "designation"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

declarationPatternWithType :: Phantoms.TTerm Syntax.DeclarationPattern -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.DeclarationPattern
declarationPatternWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.DeclarationPattern"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "designation"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DeclarationPattern"),
              Core.projectionField = (Core.Name "designation")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

declarationStatementConstant :: Phantoms.TTerm Syntax.LocalConstantDeclaration -> Phantoms.TTerm Syntax.DeclarationStatement
declarationStatementConstant x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.DeclarationStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "constant"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

declarationStatementFunction :: Phantoms.TTerm Syntax.LocalFunctionDeclaration -> Phantoms.TTerm Syntax.DeclarationStatement
declarationStatementFunction x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.DeclarationStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "function"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

declarationStatementVariable :: Phantoms.TTerm Syntax.LocalVariableDeclaration -> Phantoms.TTerm Syntax.DeclarationStatement
declarationStatementVariable x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.DeclarationStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "variable"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

deconstructionElementIdentifier :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.DeconstructionElement
deconstructionElementIdentifier x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.DeconstructionElement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "identifier"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

deconstructionElementTuple :: Phantoms.TTerm Syntax.DeconstructionTuple -> Phantoms.TTerm Syntax.DeconstructionElement
deconstructionElementTuple x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.DeconstructionElement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "tuple"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

deconstructionTuple :: Phantoms.TTerm [Syntax.DeconstructionElement] -> Phantoms.TTerm Syntax.DeconstructionTuple
deconstructionTuple x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.DeconstructionTuple"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

defaultValueExpressionDefaultLiteral :: Phantoms.TTerm Syntax.DefaultValueExpression
defaultValueExpressionDefaultLiteral =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.DefaultValueExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "defaultLiteral"),
        Core.fieldTerm = Core.TermUnit}}))

defaultValueExpressionExplicitlyTyped :: Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.DefaultValueExpression
defaultValueExpressionExplicitlyTyped x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.DefaultValueExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "explicitlyTyped"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

delegateCreationExpression :: Phantoms.TTerm Syntax.DelegateType -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.DelegateCreationExpression
delegateCreationExpression type_ expression =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.DelegateCreationExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm expression)}]}))

delegateCreationExpressionExpression :: Phantoms.TTerm Syntax.DelegateCreationExpression -> Phantoms.TTerm Syntax.Expression
delegateCreationExpressionExpression x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateCreationExpression"),
        Core.projectionField = (Core.Name "expression")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

delegateCreationExpressionType :: Phantoms.TTerm Syntax.DelegateCreationExpression -> Phantoms.TTerm Syntax.DelegateType
delegateCreationExpressionType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateCreationExpression"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

delegateCreationExpressionWithExpression :: Phantoms.TTerm Syntax.DelegateCreationExpression -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.DelegateCreationExpression
delegateCreationExpressionWithExpression original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.DelegateCreationExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateCreationExpression"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

delegateCreationExpressionWithType :: Phantoms.TTerm Syntax.DelegateCreationExpression -> Phantoms.TTerm Syntax.DelegateType -> Phantoms.TTerm Syntax.DelegateCreationExpression
delegateCreationExpressionWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.DelegateCreationExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateCreationExpression"),
              Core.projectionField = (Core.Name "expression")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

delegateDeclaration :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm [Syntax.DelegateModifier] -> Phantoms.TTerm Syntax.ReturnType -> Phantoms.TTerm (Maybe Syntax.RefKind) -> Phantoms.TTerm (Maybe Syntax.Type) -> Phantoms.TTerm Syntax.DelegateHeader -> Phantoms.TTerm Syntax.DelegateDeclaration
delegateDeclaration attributes modifiers returnType refKind refReturnType header =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm modifiers)},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Phantoms.unTTerm returnType)},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Phantoms.unTTerm refKind)},
        Core.Field {
          Core.fieldName = (Core.Name "refReturnType"),
          Core.fieldTerm = (Phantoms.unTTerm refReturnType)},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Phantoms.unTTerm header)}]}))

delegateDeclarationAttributes :: Phantoms.TTerm Syntax.DelegateDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes)
delegateDeclarationAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

delegateDeclarationHeader :: Phantoms.TTerm Syntax.DelegateDeclaration -> Phantoms.TTerm Syntax.DelegateHeader
delegateDeclarationHeader x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
        Core.projectionField = (Core.Name "header")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

delegateDeclarationModifiers :: Phantoms.TTerm Syntax.DelegateDeclaration -> Phantoms.TTerm [Syntax.DelegateModifier]
delegateDeclarationModifiers x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
        Core.projectionField = (Core.Name "modifiers")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

delegateDeclarationRefKind :: Phantoms.TTerm Syntax.DelegateDeclaration -> Phantoms.TTerm (Maybe Syntax.RefKind)
delegateDeclarationRefKind x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
        Core.projectionField = (Core.Name "refKind")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

delegateDeclarationRefReturnType :: Phantoms.TTerm Syntax.DelegateDeclaration -> Phantoms.TTerm (Maybe Syntax.Type)
delegateDeclarationRefReturnType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
        Core.projectionField = (Core.Name "refReturnType")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

delegateDeclarationReturnType :: Phantoms.TTerm Syntax.DelegateDeclaration -> Phantoms.TTerm Syntax.ReturnType
delegateDeclarationReturnType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
        Core.projectionField = (Core.Name "returnType")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

delegateDeclarationWithAttributes :: Phantoms.TTerm Syntax.DelegateDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.DelegateDeclaration
delegateDeclarationWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
              Core.projectionField = (Core.Name "returnType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refReturnType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
              Core.projectionField = (Core.Name "refReturnType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
              Core.projectionField = (Core.Name "header")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

delegateDeclarationWithHeader :: Phantoms.TTerm Syntax.DelegateDeclaration -> Phantoms.TTerm Syntax.DelegateHeader -> Phantoms.TTerm Syntax.DelegateDeclaration
delegateDeclarationWithHeader original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
              Core.projectionField = (Core.Name "returnType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refReturnType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
              Core.projectionField = (Core.Name "refReturnType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

delegateDeclarationWithModifiers :: Phantoms.TTerm Syntax.DelegateDeclaration -> Phantoms.TTerm [Syntax.DelegateModifier] -> Phantoms.TTerm Syntax.DelegateDeclaration
delegateDeclarationWithModifiers original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
              Core.projectionField = (Core.Name "returnType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refReturnType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
              Core.projectionField = (Core.Name "refReturnType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
              Core.projectionField = (Core.Name "header")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

delegateDeclarationWithRefKind :: Phantoms.TTerm Syntax.DelegateDeclaration -> Phantoms.TTerm (Maybe Syntax.RefKind) -> Phantoms.TTerm Syntax.DelegateDeclaration
delegateDeclarationWithRefKind original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
              Core.projectionField = (Core.Name "returnType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "refReturnType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
              Core.projectionField = (Core.Name "refReturnType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
              Core.projectionField = (Core.Name "header")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

delegateDeclarationWithRefReturnType :: Phantoms.TTerm Syntax.DelegateDeclaration -> Phantoms.TTerm (Maybe Syntax.Type) -> Phantoms.TTerm Syntax.DelegateDeclaration
delegateDeclarationWithRefReturnType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
              Core.projectionField = (Core.Name "returnType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refReturnType"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
              Core.projectionField = (Core.Name "header")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

delegateDeclarationWithReturnType :: Phantoms.TTerm Syntax.DelegateDeclaration -> Phantoms.TTerm Syntax.ReturnType -> Phantoms.TTerm Syntax.DelegateDeclaration
delegateDeclarationWithReturnType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refReturnType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
              Core.projectionField = (Core.Name "refReturnType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateDeclaration"),
              Core.projectionField = (Core.Name "header")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

delegateHeader :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm (Maybe Syntax.VariantTypeParameters) -> Phantoms.TTerm (Maybe Syntax.FormalParameterList) -> Phantoms.TTerm [Syntax.TypeParameterConstraintsClause] -> Phantoms.TTerm Syntax.DelegateHeader
delegateHeader name typeParameters parameters constraints =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.DelegateHeader"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm name)},
        Core.Field {
          Core.fieldName = (Core.Name "typeParameters"),
          Core.fieldTerm = (Phantoms.unTTerm typeParameters)},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Phantoms.unTTerm parameters)},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Phantoms.unTTerm constraints)}]}))

delegateHeaderConstraints :: Phantoms.TTerm Syntax.DelegateHeader -> Phantoms.TTerm [Syntax.TypeParameterConstraintsClause]
delegateHeaderConstraints x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateHeader"),
        Core.projectionField = (Core.Name "constraints")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

delegateHeaderName :: Phantoms.TTerm Syntax.DelegateHeader -> Phantoms.TTerm Syntax.Identifier
delegateHeaderName x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateHeader"),
        Core.projectionField = (Core.Name "name")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

delegateHeaderParameters :: Phantoms.TTerm Syntax.DelegateHeader -> Phantoms.TTerm (Maybe Syntax.FormalParameterList)
delegateHeaderParameters x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateHeader"),
        Core.projectionField = (Core.Name "parameters")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

delegateHeaderTypeParameters :: Phantoms.TTerm Syntax.DelegateHeader -> Phantoms.TTerm (Maybe Syntax.VariantTypeParameters)
delegateHeaderTypeParameters x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateHeader"),
        Core.projectionField = (Core.Name "typeParameters")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

delegateHeaderWithConstraints :: Phantoms.TTerm Syntax.DelegateHeader -> Phantoms.TTerm [Syntax.TypeParameterConstraintsClause] -> Phantoms.TTerm Syntax.DelegateHeader
delegateHeaderWithConstraints original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.DelegateHeader"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateHeader"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "typeParameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateHeader"),
              Core.projectionField = (Core.Name "typeParameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateHeader"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

delegateHeaderWithName :: Phantoms.TTerm Syntax.DelegateHeader -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.DelegateHeader
delegateHeaderWithName original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.DelegateHeader"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "typeParameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateHeader"),
              Core.projectionField = (Core.Name "typeParameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateHeader"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateHeader"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

delegateHeaderWithParameters :: Phantoms.TTerm Syntax.DelegateHeader -> Phantoms.TTerm (Maybe Syntax.FormalParameterList) -> Phantoms.TTerm Syntax.DelegateHeader
delegateHeaderWithParameters original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.DelegateHeader"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateHeader"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "typeParameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateHeader"),
              Core.projectionField = (Core.Name "typeParameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateHeader"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

delegateHeaderWithTypeParameters :: Phantoms.TTerm Syntax.DelegateHeader -> Phantoms.TTerm (Maybe Syntax.VariantTypeParameters) -> Phantoms.TTerm Syntax.DelegateHeader
delegateHeaderWithTypeParameters original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.DelegateHeader"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateHeader"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "typeParameters"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateHeader"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateHeader"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

delegateModifierInternal :: Phantoms.TTerm Syntax.DelegateModifier
delegateModifierInternal =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "internal"),
        Core.fieldTerm = Core.TermUnit}}))

delegateModifierNew :: Phantoms.TTerm Syntax.DelegateModifier
delegateModifierNew =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "new"),
        Core.fieldTerm = Core.TermUnit}}))

delegateModifierPrivate :: Phantoms.TTerm Syntax.DelegateModifier
delegateModifierPrivate =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "private"),
        Core.fieldTerm = Core.TermUnit}}))

delegateModifierProtected :: Phantoms.TTerm Syntax.DelegateModifier
delegateModifierProtected =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "protected"),
        Core.fieldTerm = Core.TermUnit}}))

delegateModifierPublic :: Phantoms.TTerm Syntax.DelegateModifier
delegateModifierPublic =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "public"),
        Core.fieldTerm = Core.TermUnit}}))

delegateModifierUnsafe :: Phantoms.TTerm Syntax.DelegateModifier
delegateModifierUnsafe =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.DelegateModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "unsafe"),
        Core.fieldTerm = Core.TermUnit}}))

delegateType :: Phantoms.TTerm Syntax.TypeName -> Phantoms.TTerm Syntax.DelegateType
delegateType x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.DelegateType"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

dependentAccessElementAccess :: Phantoms.TTerm Syntax.ArgumentList -> Phantoms.TTerm Syntax.DependentAccess
dependentAccessElementAccess x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.DependentAccess"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "elementAccess"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

dependentAccessForMember :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList) -> Phantoms.TTerm Syntax.DependentAccessForMember
dependentAccessForMember identifier typeArguments =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.DependentAccessForMember"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm identifier)},
        Core.Field {
          Core.fieldName = (Core.Name "typeArguments"),
          Core.fieldTerm = (Phantoms.unTTerm typeArguments)}]}))

dependentAccessForMemberIdentifier :: Phantoms.TTerm Syntax.DependentAccessForMember -> Phantoms.TTerm Syntax.Identifier
dependentAccessForMemberIdentifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DependentAccessForMember"),
        Core.projectionField = (Core.Name "identifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

dependentAccessForMemberTypeArguments :: Phantoms.TTerm Syntax.DependentAccessForMember -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList)
dependentAccessForMemberTypeArguments x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DependentAccessForMember"),
        Core.projectionField = (Core.Name "typeArguments")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

dependentAccessForMemberWithIdentifier :: Phantoms.TTerm Syntax.DependentAccessForMember -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.DependentAccessForMember
dependentAccessForMemberWithIdentifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.DependentAccessForMember"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "typeArguments"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DependentAccessForMember"),
              Core.projectionField = (Core.Name "typeArguments")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

dependentAccessForMemberWithTypeArguments :: Phantoms.TTerm Syntax.DependentAccessForMember -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList) -> Phantoms.TTerm Syntax.DependentAccessForMember
dependentAccessForMemberWithTypeArguments original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.DependentAccessForMember"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DependentAccessForMember"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "typeArguments"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

dependentAccessInvocation :: Phantoms.TTerm (Maybe Syntax.ArgumentList) -> Phantoms.TTerm Syntax.DependentAccess
dependentAccessInvocation x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.DependentAccess"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "invocation"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

dependentAccessMemberAccess :: Phantoms.TTerm Syntax.DependentAccessForMember -> Phantoms.TTerm Syntax.DependentAccess
dependentAccessMemberAccess x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.DependentAccess"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "memberAccess"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

designation :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.Designation
designation x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.Designation"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

doStatement :: Phantoms.TTerm Syntax.EmbeddedStatement -> Phantoms.TTerm Syntax.BooleanExpression -> Phantoms.TTerm Syntax.DoStatement
doStatement body while =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.DoStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)},
        Core.Field {
          Core.fieldName = (Core.Name "while"),
          Core.fieldTerm = (Phantoms.unTTerm while)}]}))

doStatementBody :: Phantoms.TTerm Syntax.DoStatement -> Phantoms.TTerm Syntax.EmbeddedStatement
doStatementBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DoStatement"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

doStatementWhile :: Phantoms.TTerm Syntax.DoStatement -> Phantoms.TTerm Syntax.BooleanExpression
doStatementWhile x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DoStatement"),
        Core.projectionField = (Core.Name "while")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

doStatementWithBody :: Phantoms.TTerm Syntax.DoStatement -> Phantoms.TTerm Syntax.EmbeddedStatement -> Phantoms.TTerm Syntax.DoStatement
doStatementWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.DoStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "while"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DoStatement"),
              Core.projectionField = (Core.Name "while")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

doStatementWithWhile :: Phantoms.TTerm Syntax.DoStatement -> Phantoms.TTerm Syntax.BooleanExpression -> Phantoms.TTerm Syntax.DoStatement
doStatementWithWhile original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.DoStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.DoStatement"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "while"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

elementAccess :: Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression -> Phantoms.TTerm Syntax.ArgumentList -> Phantoms.TTerm Syntax.ElementAccess
elementAccess expression arguments =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ElementAccess"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm expression)},
        Core.Field {
          Core.fieldName = (Core.Name "arguments"),
          Core.fieldTerm = (Phantoms.unTTerm arguments)}]}))

elementAccessArguments :: Phantoms.TTerm Syntax.ElementAccess -> Phantoms.TTerm Syntax.ArgumentList
elementAccessArguments x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ElementAccess"),
        Core.projectionField = (Core.Name "arguments")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

elementAccessExpression :: Phantoms.TTerm Syntax.ElementAccess -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression
elementAccessExpression x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ElementAccess"),
        Core.projectionField = (Core.Name "expression")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

elementAccessWithArguments :: Phantoms.TTerm Syntax.ElementAccess -> Phantoms.TTerm Syntax.ArgumentList -> Phantoms.TTerm Syntax.ElementAccess
elementAccessWithArguments original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ElementAccess"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ElementAccess"),
              Core.projectionField = (Core.Name "expression")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "arguments"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

elementAccessWithExpression :: Phantoms.TTerm Syntax.ElementAccess -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression -> Phantoms.TTerm Syntax.ElementAccess
elementAccessWithExpression original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ElementAccess"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "arguments"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ElementAccess"),
              Core.projectionField = (Core.Name "arguments")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

elementInitializerList :: Phantoms.TTerm Syntax.ExpressionList -> Phantoms.TTerm Syntax.ElementInitializer
elementInitializerList x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ElementInitializer"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "list"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

elementInitializerSingle :: Phantoms.TTerm Syntax.NonAssignmentExpression -> Phantoms.TTerm Syntax.ElementInitializer
elementInitializerSingle x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ElementInitializer"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "single"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

embeddedStatementBlock :: Phantoms.TTerm Syntax.Block -> Phantoms.TTerm Syntax.EmbeddedStatement
embeddedStatementBlock x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EmbeddedStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "block"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

embeddedStatementChecked :: Phantoms.TTerm Syntax.Block -> Phantoms.TTerm Syntax.EmbeddedStatement
embeddedStatementChecked x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EmbeddedStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "checked"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

embeddedStatementEmpty :: Phantoms.TTerm Syntax.EmbeddedStatement
embeddedStatementEmpty =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EmbeddedStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "empty"),
        Core.fieldTerm = Core.TermUnit}}))

embeddedStatementExpression :: Phantoms.TTerm Syntax.StatementExpression -> Phantoms.TTerm Syntax.EmbeddedStatement
embeddedStatementExpression x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EmbeddedStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "expression"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

embeddedStatementFixed :: Phantoms.TTerm Syntax.FixedStatement -> Phantoms.TTerm Syntax.EmbeddedStatement
embeddedStatementFixed x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EmbeddedStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "fixed"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

embeddedStatementIteration :: Phantoms.TTerm Syntax.IterationStatement -> Phantoms.TTerm Syntax.EmbeddedStatement
embeddedStatementIteration x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EmbeddedStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "iteration"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

embeddedStatementJump :: Phantoms.TTerm Syntax.JumpStatement -> Phantoms.TTerm Syntax.EmbeddedStatement
embeddedStatementJump x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EmbeddedStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "jump"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

embeddedStatementLock :: Phantoms.TTerm Syntax.LockStatement -> Phantoms.TTerm Syntax.EmbeddedStatement
embeddedStatementLock x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EmbeddedStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "lock"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

embeddedStatementSelection :: Phantoms.TTerm Syntax.SelectionStatement -> Phantoms.TTerm Syntax.EmbeddedStatement
embeddedStatementSelection x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EmbeddedStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "selection"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

embeddedStatementTry :: Phantoms.TTerm Syntax.TryStatement -> Phantoms.TTerm Syntax.EmbeddedStatement
embeddedStatementTry x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EmbeddedStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "try"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

embeddedStatementUnchecked :: Phantoms.TTerm Syntax.Block -> Phantoms.TTerm Syntax.EmbeddedStatement
embeddedStatementUnchecked x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EmbeddedStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "unchecked"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

embeddedStatementUnsafe :: Phantoms.TTerm Syntax.Block -> Phantoms.TTerm Syntax.EmbeddedStatement
embeddedStatementUnsafe x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EmbeddedStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "unsafe"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

embeddedStatementUsing :: Phantoms.TTerm Syntax.UsingStatement -> Phantoms.TTerm Syntax.EmbeddedStatement
embeddedStatementUsing x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EmbeddedStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "using"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

embeddedStatementYield :: Phantoms.TTerm Syntax.YieldStatement -> Phantoms.TTerm Syntax.EmbeddedStatement
embeddedStatementYield x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EmbeddedStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "yield"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

enumBaseName :: Phantoms.TTerm Syntax.TypeName -> Phantoms.TTerm Syntax.EnumBase
enumBaseName x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EnumBase"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "name"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

enumBaseType :: Phantoms.TTerm Syntax.IntegralType -> Phantoms.TTerm Syntax.EnumBase
enumBaseType x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EnumBase"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "type"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

enumBody :: Phantoms.TTerm [Syntax.EnumMemberDeclaration] -> Phantoms.TTerm Syntax.EnumBody
enumBody x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.EnumBody"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

enumDeclaration :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm [Syntax.EnumModifier] -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm (Maybe Syntax.EnumBase) -> Phantoms.TTerm (Maybe Syntax.EnumBody) -> Phantoms.TTerm Syntax.EnumDeclaration
enumDeclaration attributes modifiers name base body =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.EnumDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm modifiers)},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm name)},
        Core.Field {
          Core.fieldName = (Core.Name "base"),
          Core.fieldTerm = (Phantoms.unTTerm base)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)}]}))

enumDeclarationAttributes :: Phantoms.TTerm Syntax.EnumDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes)
enumDeclarationAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumDeclaration"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

enumDeclarationBase :: Phantoms.TTerm Syntax.EnumDeclaration -> Phantoms.TTerm (Maybe Syntax.EnumBase)
enumDeclarationBase x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumDeclaration"),
        Core.projectionField = (Core.Name "base")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

enumDeclarationBody :: Phantoms.TTerm Syntax.EnumDeclaration -> Phantoms.TTerm (Maybe Syntax.EnumBody)
enumDeclarationBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumDeclaration"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

enumDeclarationModifiers :: Phantoms.TTerm Syntax.EnumDeclaration -> Phantoms.TTerm [Syntax.EnumModifier]
enumDeclarationModifiers x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumDeclaration"),
        Core.projectionField = (Core.Name "modifiers")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

enumDeclarationName :: Phantoms.TTerm Syntax.EnumDeclaration -> Phantoms.TTerm Syntax.Identifier
enumDeclarationName x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumDeclaration"),
        Core.projectionField = (Core.Name "name")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

enumDeclarationWithAttributes :: Phantoms.TTerm Syntax.EnumDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.EnumDeclaration
enumDeclarationWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.EnumDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "base"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumDeclaration"),
              Core.projectionField = (Core.Name "base")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

enumDeclarationWithBase :: Phantoms.TTerm Syntax.EnumDeclaration -> Phantoms.TTerm (Maybe Syntax.EnumBase) -> Phantoms.TTerm Syntax.EnumDeclaration
enumDeclarationWithBase original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.EnumDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "base"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

enumDeclarationWithBody :: Phantoms.TTerm Syntax.EnumDeclaration -> Phantoms.TTerm (Maybe Syntax.EnumBody) -> Phantoms.TTerm Syntax.EnumDeclaration
enumDeclarationWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.EnumDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "base"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumDeclaration"),
              Core.projectionField = (Core.Name "base")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

enumDeclarationWithModifiers :: Phantoms.TTerm Syntax.EnumDeclaration -> Phantoms.TTerm [Syntax.EnumModifier] -> Phantoms.TTerm Syntax.EnumDeclaration
enumDeclarationWithModifiers original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.EnumDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "base"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumDeclaration"),
              Core.projectionField = (Core.Name "base")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

enumDeclarationWithName :: Phantoms.TTerm Syntax.EnumDeclaration -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.EnumDeclaration
enumDeclarationWithName original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.EnumDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "base"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumDeclaration"),
              Core.projectionField = (Core.Name "base")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

enumMemberDeclaration :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm (Maybe Syntax.ConstantExpression) -> Phantoms.TTerm Syntax.EnumMemberDeclaration
enumMemberDeclaration attributes name value =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.EnumMemberDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm name)},
        Core.Field {
          Core.fieldName = (Core.Name "value"),
          Core.fieldTerm = (Phantoms.unTTerm value)}]}))

enumMemberDeclarationAttributes :: Phantoms.TTerm Syntax.EnumMemberDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes)
enumMemberDeclarationAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumMemberDeclaration"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

enumMemberDeclarationName :: Phantoms.TTerm Syntax.EnumMemberDeclaration -> Phantoms.TTerm Syntax.Identifier
enumMemberDeclarationName x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumMemberDeclaration"),
        Core.projectionField = (Core.Name "name")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

enumMemberDeclarationValue :: Phantoms.TTerm Syntax.EnumMemberDeclaration -> Phantoms.TTerm (Maybe Syntax.ConstantExpression)
enumMemberDeclarationValue x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumMemberDeclaration"),
        Core.projectionField = (Core.Name "value")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

enumMemberDeclarationWithAttributes :: Phantoms.TTerm Syntax.EnumMemberDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.EnumMemberDeclaration
enumMemberDeclarationWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.EnumMemberDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumMemberDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "value"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumMemberDeclaration"),
              Core.projectionField = (Core.Name "value")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

enumMemberDeclarationWithName :: Phantoms.TTerm Syntax.EnumMemberDeclaration -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.EnumMemberDeclaration
enumMemberDeclarationWithName original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.EnumMemberDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumMemberDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "value"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumMemberDeclaration"),
              Core.projectionField = (Core.Name "value")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

enumMemberDeclarationWithValue :: Phantoms.TTerm Syntax.EnumMemberDeclaration -> Phantoms.TTerm (Maybe Syntax.ConstantExpression) -> Phantoms.TTerm Syntax.EnumMemberDeclaration
enumMemberDeclarationWithValue original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.EnumMemberDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumMemberDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.EnumMemberDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "value"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

enumModifierInternal :: Phantoms.TTerm Syntax.EnumModifier
enumModifierInternal =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EnumModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "internal"),
        Core.fieldTerm = Core.TermUnit}}))

enumModifierNew :: Phantoms.TTerm Syntax.EnumModifier
enumModifierNew =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EnumModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "new"),
        Core.fieldTerm = Core.TermUnit}}))

enumModifierPrivate :: Phantoms.TTerm Syntax.EnumModifier
enumModifierPrivate =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EnumModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "private"),
        Core.fieldTerm = Core.TermUnit}}))

enumModifierProtected :: Phantoms.TTerm Syntax.EnumModifier
enumModifierProtected =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EnumModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "protected"),
        Core.fieldTerm = Core.TermUnit}}))

enumModifierPublic :: Phantoms.TTerm Syntax.EnumModifier
enumModifierPublic =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EnumModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "public"),
        Core.fieldTerm = Core.TermUnit}}))

enumType :: Phantoms.TTerm Syntax.TypeName -> Phantoms.TTerm Syntax.EnumType
enumType x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.EnumType"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

equalityExpressionBinary :: Phantoms.TTerm Syntax.BinaryEqualityExpression -> Phantoms.TTerm Syntax.EqualityExpression
equalityExpressionBinary x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EqualityExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "binary"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

equalityExpressionSimple :: Phantoms.TTerm Syntax.RelationalExpression -> Phantoms.TTerm Syntax.EqualityExpression
equalityExpressionSimple x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EqualityExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "simple"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

equalityOperatorEqual :: Phantoms.TTerm Syntax.EqualityOperator
equalityOperatorEqual =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EqualityOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "equal"),
        Core.fieldTerm = Core.TermUnit}}))

equalityOperatorNotEqual :: Phantoms.TTerm Syntax.EqualityOperator
equalityOperatorNotEqual =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EqualityOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "notEqual"),
        Core.fieldTerm = Core.TermUnit}}))

eventAccessorDeclarationsAdd :: Phantoms.TTerm Syntax.AddRemoveAccessorDeclaration -> Phantoms.TTerm Syntax.EventAccessorDeclarations
eventAccessorDeclarationsAdd x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EventAccessorDeclarations"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "add"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

eventAccessorDeclarationsRemove :: Phantoms.TTerm Syntax.AddRemoveAccessorDeclaration -> Phantoms.TTerm Syntax.EventAccessorDeclarations
eventAccessorDeclarationsRemove x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EventAccessorDeclarations"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "remove"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

eventDeclarationAccessors :: Phantoms.TTerm Syntax.AccessorsEventDeclaration -> Phantoms.TTerm Syntax.EventDeclaration
eventDeclarationAccessors x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EventDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "accessors"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

eventDeclarationStandard :: Phantoms.TTerm Syntax.StandardEventDeclaration -> Phantoms.TTerm Syntax.EventDeclaration
eventDeclarationStandard x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EventDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "standard"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

eventModifierAbstract :: Phantoms.TTerm Syntax.EventModifier
eventModifierAbstract =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EventModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "abstract"),
        Core.fieldTerm = Core.TermUnit}}))

eventModifierExtern :: Phantoms.TTerm Syntax.EventModifier
eventModifierExtern =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EventModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "extern"),
        Core.fieldTerm = Core.TermUnit}}))

eventModifierInternal :: Phantoms.TTerm Syntax.EventModifier
eventModifierInternal =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EventModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "internal"),
        Core.fieldTerm = Core.TermUnit}}))

eventModifierNew :: Phantoms.TTerm Syntax.EventModifier
eventModifierNew =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EventModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "new"),
        Core.fieldTerm = Core.TermUnit}}))

eventModifierOverride :: Phantoms.TTerm Syntax.EventModifier
eventModifierOverride =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EventModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "override"),
        Core.fieldTerm = Core.TermUnit}}))

eventModifierPrivate :: Phantoms.TTerm Syntax.EventModifier
eventModifierPrivate =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EventModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "private"),
        Core.fieldTerm = Core.TermUnit}}))

eventModifierProtected :: Phantoms.TTerm Syntax.EventModifier
eventModifierProtected =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EventModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "protected"),
        Core.fieldTerm = Core.TermUnit}}))

eventModifierPublic :: Phantoms.TTerm Syntax.EventModifier
eventModifierPublic =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EventModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "public"),
        Core.fieldTerm = Core.TermUnit}}))

eventModifierSealed :: Phantoms.TTerm Syntax.EventModifier
eventModifierSealed =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EventModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "sealed"),
        Core.fieldTerm = Core.TermUnit}}))

eventModifierStatic :: Phantoms.TTerm Syntax.EventModifier
eventModifierStatic =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EventModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "static"),
        Core.fieldTerm = Core.TermUnit}}))

eventModifierUnsafe :: Phantoms.TTerm Syntax.EventModifier
eventModifierUnsafe =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EventModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "unsafe"),
        Core.fieldTerm = Core.TermUnit}}))

eventModifierVirtual :: Phantoms.TTerm Syntax.EventModifier
eventModifierVirtual =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.EventModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "virtual"),
        Core.fieldTerm = Core.TermUnit}}))

exceptionSpecifier :: Phantoms.TTerm Syntax.Type -> Phantoms.TTerm (Maybe Syntax.Identifier) -> Phantoms.TTerm Syntax.ExceptionSpecifier
exceptionSpecifier type_ identifier =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ExceptionSpecifier"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm identifier)}]}))

exceptionSpecifierIdentifier :: Phantoms.TTerm Syntax.ExceptionSpecifier -> Phantoms.TTerm (Maybe Syntax.Identifier)
exceptionSpecifierIdentifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ExceptionSpecifier"),
        Core.projectionField = (Core.Name "identifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

exceptionSpecifierType :: Phantoms.TTerm Syntax.ExceptionSpecifier -> Phantoms.TTerm Syntax.Type
exceptionSpecifierType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ExceptionSpecifier"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

exceptionSpecifierWithIdentifier :: Phantoms.TTerm Syntax.ExceptionSpecifier -> Phantoms.TTerm (Maybe Syntax.Identifier) -> Phantoms.TTerm Syntax.ExceptionSpecifier
exceptionSpecifierWithIdentifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ExceptionSpecifier"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ExceptionSpecifier"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

exceptionSpecifierWithType :: Phantoms.TTerm Syntax.ExceptionSpecifier -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.ExceptionSpecifier
exceptionSpecifierWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ExceptionSpecifier"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ExceptionSpecifier"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

exclusiveOrExpressionBinary :: Phantoms.TTerm Syntax.BinaryExclusiveOrExpression -> Phantoms.TTerm Syntax.ExclusiveOrExpression
exclusiveOrExpressionBinary x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ExclusiveOrExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "binary"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

exclusiveOrExpressionSimple :: Phantoms.TTerm Syntax.AndExpression -> Phantoms.TTerm Syntax.ExclusiveOrExpression
exclusiveOrExpressionSimple x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ExclusiveOrExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "simple"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

explicitAnonymousFunctionParameter :: Phantoms.TTerm (Maybe Syntax.AnonymousFunctionParameterModifier) -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.ExplicitAnonymousFunctionParameter
explicitAnonymousFunctionParameter modifier type_ identifier =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ExplicitAnonymousFunctionParameter"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "modifier"),
          Core.fieldTerm = (Phantoms.unTTerm modifier)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm identifier)}]}))

explicitAnonymousFunctionParameterIdentifier :: Phantoms.TTerm Syntax.ExplicitAnonymousFunctionParameter -> Phantoms.TTerm Syntax.Identifier
explicitAnonymousFunctionParameterIdentifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ExplicitAnonymousFunctionParameter"),
        Core.projectionField = (Core.Name "identifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

explicitAnonymousFunctionParameterModifier :: Phantoms.TTerm Syntax.ExplicitAnonymousFunctionParameter -> Phantoms.TTerm (Maybe Syntax.AnonymousFunctionParameterModifier)
explicitAnonymousFunctionParameterModifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ExplicitAnonymousFunctionParameter"),
        Core.projectionField = (Core.Name "modifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

explicitAnonymousFunctionParameterType :: Phantoms.TTerm Syntax.ExplicitAnonymousFunctionParameter -> Phantoms.TTerm Syntax.Type
explicitAnonymousFunctionParameterType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ExplicitAnonymousFunctionParameter"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

explicitAnonymousFunctionParameterWithIdentifier :: Phantoms.TTerm Syntax.ExplicitAnonymousFunctionParameter -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.ExplicitAnonymousFunctionParameter
explicitAnonymousFunctionParameterWithIdentifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ExplicitAnonymousFunctionParameter"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "modifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ExplicitAnonymousFunctionParameter"),
              Core.projectionField = (Core.Name "modifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ExplicitAnonymousFunctionParameter"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

explicitAnonymousFunctionParameterWithModifier :: Phantoms.TTerm Syntax.ExplicitAnonymousFunctionParameter -> Phantoms.TTerm (Maybe Syntax.AnonymousFunctionParameterModifier) -> Phantoms.TTerm Syntax.ExplicitAnonymousFunctionParameter
explicitAnonymousFunctionParameterWithModifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ExplicitAnonymousFunctionParameter"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "modifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ExplicitAnonymousFunctionParameter"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ExplicitAnonymousFunctionParameter"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

explicitAnonymousFunctionParameterWithType :: Phantoms.TTerm Syntax.ExplicitAnonymousFunctionParameter -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.ExplicitAnonymousFunctionParameter
explicitAnonymousFunctionParameterWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ExplicitAnonymousFunctionParameter"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "modifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ExplicitAnonymousFunctionParameter"),
              Core.projectionField = (Core.Name "modifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ExplicitAnonymousFunctionParameter"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

explicitlyTypedLocalVariableDeclaration :: Phantoms.TTerm Syntax.Type -> Phantoms.TTerm [Syntax.ExplicitlyTypedLocalVariableDeclarator] -> Phantoms.TTerm Syntax.ExplicitlyTypedLocalVariableDeclaration
explicitlyTypedLocalVariableDeclaration type_ declarators =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Phantoms.unTTerm declarators)}]}))

explicitlyTypedLocalVariableDeclarationDeclarators :: Phantoms.TTerm Syntax.ExplicitlyTypedLocalVariableDeclaration -> Phantoms.TTerm [Syntax.ExplicitlyTypedLocalVariableDeclarator]
explicitlyTypedLocalVariableDeclarationDeclarators x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration"),
        Core.projectionField = (Core.Name "declarators")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

explicitlyTypedLocalVariableDeclarationType :: Phantoms.TTerm Syntax.ExplicitlyTypedLocalVariableDeclaration -> Phantoms.TTerm Syntax.Type
explicitlyTypedLocalVariableDeclarationType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

explicitlyTypedLocalVariableDeclarationWithDeclarators :: Phantoms.TTerm Syntax.ExplicitlyTypedLocalVariableDeclaration -> Phantoms.TTerm [Syntax.ExplicitlyTypedLocalVariableDeclarator] -> Phantoms.TTerm Syntax.ExplicitlyTypedLocalVariableDeclaration
explicitlyTypedLocalVariableDeclarationWithDeclarators original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

explicitlyTypedLocalVariableDeclarationWithType :: Phantoms.TTerm Syntax.ExplicitlyTypedLocalVariableDeclaration -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.ExplicitlyTypedLocalVariableDeclaration
explicitlyTypedLocalVariableDeclarationWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ExplicitlyTypedLocalVariableDeclaration"),
              Core.projectionField = (Core.Name "declarators")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

explicitlyTypedLocalVariableDeclarator :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm (Maybe Syntax.LocalVariableInitializer) -> Phantoms.TTerm Syntax.ExplicitlyTypedLocalVariableDeclarator
explicitlyTypedLocalVariableDeclarator identifier initializer =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm identifier)},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Phantoms.unTTerm initializer)}]}))

explicitlyTypedLocalVariableDeclaratorIdentifier :: Phantoms.TTerm Syntax.ExplicitlyTypedLocalVariableDeclarator -> Phantoms.TTerm Syntax.Identifier
explicitlyTypedLocalVariableDeclaratorIdentifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator"),
        Core.projectionField = (Core.Name "identifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

explicitlyTypedLocalVariableDeclaratorInitializer :: Phantoms.TTerm Syntax.ExplicitlyTypedLocalVariableDeclarator -> Phantoms.TTerm (Maybe Syntax.LocalVariableInitializer)
explicitlyTypedLocalVariableDeclaratorInitializer x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator"),
        Core.projectionField = (Core.Name "initializer")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

explicitlyTypedLocalVariableDeclaratorWithIdentifier :: Phantoms.TTerm Syntax.ExplicitlyTypedLocalVariableDeclarator -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.ExplicitlyTypedLocalVariableDeclarator
explicitlyTypedLocalVariableDeclaratorWithIdentifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator"),
              Core.projectionField = (Core.Name "initializer")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

explicitlyTypedLocalVariableDeclaratorWithInitializer :: Phantoms.TTerm Syntax.ExplicitlyTypedLocalVariableDeclarator -> Phantoms.TTerm (Maybe Syntax.LocalVariableInitializer) -> Phantoms.TTerm Syntax.ExplicitlyTypedLocalVariableDeclarator
explicitlyTypedLocalVariableDeclaratorWithInitializer original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ExplicitlyTypedLocalVariableDeclarator"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

expressionAssignment :: Phantoms.TTerm Syntax.Assignment -> Phantoms.TTerm Syntax.Expression
expressionAssignment x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.Expression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "assignment"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

expressionList :: Phantoms.TTerm [Syntax.Expression] -> Phantoms.TTerm Syntax.ExpressionList
expressionList x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.ExpressionList"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

expressionNonAssignment :: Phantoms.TTerm Syntax.NonAssignmentExpression -> Phantoms.TTerm Syntax.Expression
expressionNonAssignment x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.Expression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "nonAssignment"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

externAliasDirective :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.ExternAliasDirective
externAliasDirective x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.ExternAliasDirective"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

fieldDeclaration :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm [Syntax.FieldModifier] -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm [Syntax.VariableDeclarator] -> Phantoms.TTerm Syntax.FieldDeclaration
fieldDeclaration attributes modifiers type_ declarators =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FieldDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm modifiers)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Phantoms.unTTerm declarators)}]}))

fieldDeclarationAttributes :: Phantoms.TTerm Syntax.FieldDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes)
fieldDeclarationAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FieldDeclaration"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

fieldDeclarationDeclarators :: Phantoms.TTerm Syntax.FieldDeclaration -> Phantoms.TTerm [Syntax.VariableDeclarator]
fieldDeclarationDeclarators x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FieldDeclaration"),
        Core.projectionField = (Core.Name "declarators")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

fieldDeclarationModifiers :: Phantoms.TTerm Syntax.FieldDeclaration -> Phantoms.TTerm [Syntax.FieldModifier]
fieldDeclarationModifiers x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FieldDeclaration"),
        Core.projectionField = (Core.Name "modifiers")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

fieldDeclarationType :: Phantoms.TTerm Syntax.FieldDeclaration -> Phantoms.TTerm Syntax.Type
fieldDeclarationType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FieldDeclaration"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

fieldDeclarationWithAttributes :: Phantoms.TTerm Syntax.FieldDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.FieldDeclaration
fieldDeclarationWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FieldDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FieldDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FieldDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FieldDeclaration"),
              Core.projectionField = (Core.Name "declarators")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

fieldDeclarationWithDeclarators :: Phantoms.TTerm Syntax.FieldDeclaration -> Phantoms.TTerm [Syntax.VariableDeclarator] -> Phantoms.TTerm Syntax.FieldDeclaration
fieldDeclarationWithDeclarators original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FieldDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FieldDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FieldDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FieldDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

fieldDeclarationWithModifiers :: Phantoms.TTerm Syntax.FieldDeclaration -> Phantoms.TTerm [Syntax.FieldModifier] -> Phantoms.TTerm Syntax.FieldDeclaration
fieldDeclarationWithModifiers original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FieldDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FieldDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FieldDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FieldDeclaration"),
              Core.projectionField = (Core.Name "declarators")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

fieldDeclarationWithType :: Phantoms.TTerm Syntax.FieldDeclaration -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.FieldDeclaration
fieldDeclarationWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FieldDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FieldDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FieldDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FieldDeclaration"),
              Core.projectionField = (Core.Name "declarators")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

fieldModifierInternal :: Phantoms.TTerm Syntax.FieldModifier
fieldModifierInternal =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.FieldModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "internal"),
        Core.fieldTerm = Core.TermUnit}}))

fieldModifierNew :: Phantoms.TTerm Syntax.FieldModifier
fieldModifierNew =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.FieldModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "new"),
        Core.fieldTerm = Core.TermUnit}}))

fieldModifierPrivate :: Phantoms.TTerm Syntax.FieldModifier
fieldModifierPrivate =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.FieldModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "private"),
        Core.fieldTerm = Core.TermUnit}}))

fieldModifierProtected :: Phantoms.TTerm Syntax.FieldModifier
fieldModifierProtected =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.FieldModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "protected"),
        Core.fieldTerm = Core.TermUnit}}))

fieldModifierPublic :: Phantoms.TTerm Syntax.FieldModifier
fieldModifierPublic =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.FieldModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "public"),
        Core.fieldTerm = Core.TermUnit}}))

fieldModifierReadonly :: Phantoms.TTerm Syntax.FieldModifier
fieldModifierReadonly =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.FieldModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "readonly"),
        Core.fieldTerm = Core.TermUnit}}))

fieldModifierStatic :: Phantoms.TTerm Syntax.FieldModifier
fieldModifierStatic =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.FieldModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "static"),
        Core.fieldTerm = Core.TermUnit}}))

fieldModifierUnsafe :: Phantoms.TTerm Syntax.FieldModifier
fieldModifierUnsafe =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.FieldModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "unsafe"),
        Core.fieldTerm = Core.TermUnit}}))

fieldModifierVolatile :: Phantoms.TTerm Syntax.FieldModifier
fieldModifierVolatile =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.FieldModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "volatile"),
        Core.fieldTerm = Core.TermUnit}}))

finalizerBodyBlock :: Phantoms.TTerm Syntax.Block -> Phantoms.TTerm Syntax.FinalizerBody
finalizerBodyBlock x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.FinalizerBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "block"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

finalizerBodyEmpty :: Phantoms.TTerm Syntax.FinalizerBody
finalizerBodyEmpty =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.FinalizerBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "empty"),
        Core.fieldTerm = Core.TermUnit}}))

finalizerBodyExpression :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.FinalizerBody
finalizerBodyExpression x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.FinalizerBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "expression"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

finalizerDeclaration :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Bool -> Phantoms.TTerm Bool -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.FinalizerBody -> Phantoms.TTerm Syntax.FinalizerDeclaration
finalizerDeclaration attributes extern unsafe name body =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FinalizerDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "extern"),
          Core.fieldTerm = (Phantoms.unTTerm extern)},
        Core.Field {
          Core.fieldName = (Core.Name "unsafe"),
          Core.fieldTerm = (Phantoms.unTTerm unsafe)},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm name)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)}]}))

finalizerDeclarationAttributes :: Phantoms.TTerm Syntax.FinalizerDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes)
finalizerDeclarationAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FinalizerDeclaration"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

finalizerDeclarationBody :: Phantoms.TTerm Syntax.FinalizerDeclaration -> Phantoms.TTerm Syntax.FinalizerBody
finalizerDeclarationBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FinalizerDeclaration"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

finalizerDeclarationExtern :: Phantoms.TTerm Syntax.FinalizerDeclaration -> Phantoms.TTerm Bool
finalizerDeclarationExtern x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FinalizerDeclaration"),
        Core.projectionField = (Core.Name "extern")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

finalizerDeclarationName :: Phantoms.TTerm Syntax.FinalizerDeclaration -> Phantoms.TTerm Syntax.Identifier
finalizerDeclarationName x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FinalizerDeclaration"),
        Core.projectionField = (Core.Name "name")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

finalizerDeclarationUnsafe :: Phantoms.TTerm Syntax.FinalizerDeclaration -> Phantoms.TTerm Bool
finalizerDeclarationUnsafe x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FinalizerDeclaration"),
        Core.projectionField = (Core.Name "unsafe")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

finalizerDeclarationWithAttributes :: Phantoms.TTerm Syntax.FinalizerDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.FinalizerDeclaration
finalizerDeclarationWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FinalizerDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "extern"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FinalizerDeclaration"),
              Core.projectionField = (Core.Name "extern")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "unsafe"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FinalizerDeclaration"),
              Core.projectionField = (Core.Name "unsafe")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FinalizerDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FinalizerDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

finalizerDeclarationWithBody :: Phantoms.TTerm Syntax.FinalizerDeclaration -> Phantoms.TTerm Syntax.FinalizerBody -> Phantoms.TTerm Syntax.FinalizerDeclaration
finalizerDeclarationWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FinalizerDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FinalizerDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "extern"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FinalizerDeclaration"),
              Core.projectionField = (Core.Name "extern")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "unsafe"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FinalizerDeclaration"),
              Core.projectionField = (Core.Name "unsafe")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FinalizerDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

finalizerDeclarationWithExtern :: Phantoms.TTerm Syntax.FinalizerDeclaration -> Phantoms.TTerm Bool -> Phantoms.TTerm Syntax.FinalizerDeclaration
finalizerDeclarationWithExtern original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FinalizerDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FinalizerDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "extern"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "unsafe"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FinalizerDeclaration"),
              Core.projectionField = (Core.Name "unsafe")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FinalizerDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FinalizerDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

finalizerDeclarationWithName :: Phantoms.TTerm Syntax.FinalizerDeclaration -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.FinalizerDeclaration
finalizerDeclarationWithName original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FinalizerDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FinalizerDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "extern"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FinalizerDeclaration"),
              Core.projectionField = (Core.Name "extern")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "unsafe"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FinalizerDeclaration"),
              Core.projectionField = (Core.Name "unsafe")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FinalizerDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

finalizerDeclarationWithUnsafe :: Phantoms.TTerm Syntax.FinalizerDeclaration -> Phantoms.TTerm Bool -> Phantoms.TTerm Syntax.FinalizerDeclaration
finalizerDeclarationWithUnsafe original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FinalizerDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FinalizerDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "extern"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FinalizerDeclaration"),
              Core.projectionField = (Core.Name "extern")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "unsafe"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FinalizerDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FinalizerDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

fixedParameter :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm (Maybe Syntax.ParameterModifier) -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm (Maybe Syntax.Expression) -> Phantoms.TTerm Syntax.FixedParameter
fixedParameter attributes modifier type_ identifier defaultArgument =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FixedParameter"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "modifier"),
          Core.fieldTerm = (Phantoms.unTTerm modifier)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm identifier)},
        Core.Field {
          Core.fieldName = (Core.Name "defaultArgument"),
          Core.fieldTerm = (Phantoms.unTTerm defaultArgument)}]}))

fixedParameterAttributes :: Phantoms.TTerm Syntax.FixedParameter -> Phantoms.TTerm (Maybe Syntax.Attributes)
fixedParameterAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedParameter"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

fixedParameterDefaultArgument :: Phantoms.TTerm Syntax.FixedParameter -> Phantoms.TTerm (Maybe Syntax.Expression)
fixedParameterDefaultArgument x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedParameter"),
        Core.projectionField = (Core.Name "defaultArgument")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

fixedParameterIdentifier :: Phantoms.TTerm Syntax.FixedParameter -> Phantoms.TTerm Syntax.Identifier
fixedParameterIdentifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedParameter"),
        Core.projectionField = (Core.Name "identifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

fixedParameterModifier :: Phantoms.TTerm Syntax.FixedParameter -> Phantoms.TTerm (Maybe Syntax.ParameterModifier)
fixedParameterModifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedParameter"),
        Core.projectionField = (Core.Name "modifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

fixedParameterType :: Phantoms.TTerm Syntax.FixedParameter -> Phantoms.TTerm Syntax.Type
fixedParameterType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedParameter"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

fixedParameterWithAttributes :: Phantoms.TTerm Syntax.FixedParameter -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.FixedParameter
fixedParameterWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FixedParameter"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "modifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedParameter"),
              Core.projectionField = (Core.Name "modifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedParameter"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedParameter"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "defaultArgument"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedParameter"),
              Core.projectionField = (Core.Name "defaultArgument")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

fixedParameterWithDefaultArgument :: Phantoms.TTerm Syntax.FixedParameter -> Phantoms.TTerm (Maybe Syntax.Expression) -> Phantoms.TTerm Syntax.FixedParameter
fixedParameterWithDefaultArgument original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FixedParameter"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedParameter"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedParameter"),
              Core.projectionField = (Core.Name "modifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedParameter"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedParameter"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "defaultArgument"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

fixedParameterWithIdentifier :: Phantoms.TTerm Syntax.FixedParameter -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.FixedParameter
fixedParameterWithIdentifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FixedParameter"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedParameter"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedParameter"),
              Core.projectionField = (Core.Name "modifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedParameter"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "defaultArgument"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedParameter"),
              Core.projectionField = (Core.Name "defaultArgument")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

fixedParameterWithModifier :: Phantoms.TTerm Syntax.FixedParameter -> Phantoms.TTerm (Maybe Syntax.ParameterModifier) -> Phantoms.TTerm Syntax.FixedParameter
fixedParameterWithModifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FixedParameter"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedParameter"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedParameter"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedParameter"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "defaultArgument"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedParameter"),
              Core.projectionField = (Core.Name "defaultArgument")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

fixedParameterWithType :: Phantoms.TTerm Syntax.FixedParameter -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.FixedParameter
fixedParameterWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FixedParameter"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedParameter"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedParameter"),
              Core.projectionField = (Core.Name "modifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedParameter"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "defaultArgument"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedParameter"),
              Core.projectionField = (Core.Name "defaultArgument")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

fixedPointerDeclaratorExpression :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.FixedPointerDeclarator
fixedPointerDeclaratorExpression x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.FixedPointerDeclarator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "expression"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

fixedPointerDeclaratorReference :: Phantoms.TTerm Syntax.VariableReference -> Phantoms.TTerm Syntax.FixedPointerDeclarator
fixedPointerDeclaratorReference x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.FixedPointerDeclarator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "reference"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

fixedSizeBufferDeclaration :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm [Syntax.FixedSizeBufferModifier] -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm [Syntax.FixedSizeBufferDeclarator] -> Phantoms.TTerm Syntax.FixedSizeBufferDeclaration
fixedSizeBufferDeclaration attributes modifiers elementType declarators =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm modifiers)},
        Core.Field {
          Core.fieldName = (Core.Name "elementType"),
          Core.fieldTerm = (Phantoms.unTTerm elementType)},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Phantoms.unTTerm declarators)}]}))

fixedSizeBufferDeclarationAttributes :: Phantoms.TTerm Syntax.FixedSizeBufferDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes)
fixedSizeBufferDeclarationAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferDeclaration"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

fixedSizeBufferDeclarationDeclarators :: Phantoms.TTerm Syntax.FixedSizeBufferDeclaration -> Phantoms.TTerm [Syntax.FixedSizeBufferDeclarator]
fixedSizeBufferDeclarationDeclarators x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferDeclaration"),
        Core.projectionField = (Core.Name "declarators")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

fixedSizeBufferDeclarationElementType :: Phantoms.TTerm Syntax.FixedSizeBufferDeclaration -> Phantoms.TTerm Syntax.Type
fixedSizeBufferDeclarationElementType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferDeclaration"),
        Core.projectionField = (Core.Name "elementType")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

fixedSizeBufferDeclarationModifiers :: Phantoms.TTerm Syntax.FixedSizeBufferDeclaration -> Phantoms.TTerm [Syntax.FixedSizeBufferModifier]
fixedSizeBufferDeclarationModifiers x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferDeclaration"),
        Core.projectionField = (Core.Name "modifiers")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

fixedSizeBufferDeclarationWithAttributes :: Phantoms.TTerm Syntax.FixedSizeBufferDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.FixedSizeBufferDeclaration
fixedSizeBufferDeclarationWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "elementType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferDeclaration"),
              Core.projectionField = (Core.Name "elementType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferDeclaration"),
              Core.projectionField = (Core.Name "declarators")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

fixedSizeBufferDeclarationWithDeclarators :: Phantoms.TTerm Syntax.FixedSizeBufferDeclaration -> Phantoms.TTerm [Syntax.FixedSizeBufferDeclarator] -> Phantoms.TTerm Syntax.FixedSizeBufferDeclaration
fixedSizeBufferDeclarationWithDeclarators original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "elementType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferDeclaration"),
              Core.projectionField = (Core.Name "elementType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

fixedSizeBufferDeclarationWithElementType :: Phantoms.TTerm Syntax.FixedSizeBufferDeclaration -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.FixedSizeBufferDeclaration
fixedSizeBufferDeclarationWithElementType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "elementType"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferDeclaration"),
              Core.projectionField = (Core.Name "declarators")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

fixedSizeBufferDeclarationWithModifiers :: Phantoms.TTerm Syntax.FixedSizeBufferDeclaration -> Phantoms.TTerm [Syntax.FixedSizeBufferModifier] -> Phantoms.TTerm Syntax.FixedSizeBufferDeclaration
fixedSizeBufferDeclarationWithModifiers original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "elementType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferDeclaration"),
              Core.projectionField = (Core.Name "elementType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferDeclaration"),
              Core.projectionField = (Core.Name "declarators")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

fixedSizeBufferDeclarator :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.ConstantExpression -> Phantoms.TTerm Syntax.FixedSizeBufferDeclarator
fixedSizeBufferDeclarator name size =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm name)},
        Core.Field {
          Core.fieldName = (Core.Name "size"),
          Core.fieldTerm = (Phantoms.unTTerm size)}]}))

fixedSizeBufferDeclaratorName :: Phantoms.TTerm Syntax.FixedSizeBufferDeclarator -> Phantoms.TTerm Syntax.Identifier
fixedSizeBufferDeclaratorName x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferDeclarator"),
        Core.projectionField = (Core.Name "name")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

fixedSizeBufferDeclaratorSize :: Phantoms.TTerm Syntax.FixedSizeBufferDeclarator -> Phantoms.TTerm Syntax.ConstantExpression
fixedSizeBufferDeclaratorSize x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferDeclarator"),
        Core.projectionField = (Core.Name "size")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

fixedSizeBufferDeclaratorWithName :: Phantoms.TTerm Syntax.FixedSizeBufferDeclarator -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.FixedSizeBufferDeclarator
fixedSizeBufferDeclaratorWithName original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "size"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferDeclarator"),
              Core.projectionField = (Core.Name "size")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

fixedSizeBufferDeclaratorWithSize :: Phantoms.TTerm Syntax.FixedSizeBufferDeclarator -> Phantoms.TTerm Syntax.ConstantExpression -> Phantoms.TTerm Syntax.FixedSizeBufferDeclarator
fixedSizeBufferDeclaratorWithSize original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferDeclarator"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "size"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

fixedSizeBufferModifierInternal :: Phantoms.TTerm Syntax.FixedSizeBufferModifier
fixedSizeBufferModifierInternal =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "internal"),
        Core.fieldTerm = Core.TermUnit}}))

fixedSizeBufferModifierNew :: Phantoms.TTerm Syntax.FixedSizeBufferModifier
fixedSizeBufferModifierNew =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "new"),
        Core.fieldTerm = Core.TermUnit}}))

fixedSizeBufferModifierPrivate :: Phantoms.TTerm Syntax.FixedSizeBufferModifier
fixedSizeBufferModifierPrivate =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "private"),
        Core.fieldTerm = Core.TermUnit}}))

fixedSizeBufferModifierPublic :: Phantoms.TTerm Syntax.FixedSizeBufferModifier
fixedSizeBufferModifierPublic =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "public"),
        Core.fieldTerm = Core.TermUnit}}))

fixedSizeBufferModifierUnsafe :: Phantoms.TTerm Syntax.FixedSizeBufferModifier
fixedSizeBufferModifierUnsafe =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.FixedSizeBufferModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "unsafe"),
        Core.fieldTerm = Core.TermUnit}}))

fixedStatement :: Phantoms.TTerm Syntax.PointerType -> Phantoms.TTerm [Syntax.FixedPointerDeclarator] -> Phantoms.TTerm Syntax.EmbeddedStatement -> Phantoms.TTerm Syntax.FixedStatement
fixedStatement pointerType declarators statement =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FixedStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "pointerType"),
          Core.fieldTerm = (Phantoms.unTTerm pointerType)},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Phantoms.unTTerm declarators)},
        Core.Field {
          Core.fieldName = (Core.Name "statement"),
          Core.fieldTerm = (Phantoms.unTTerm statement)}]}))

fixedStatementDeclarators :: Phantoms.TTerm Syntax.FixedStatement -> Phantoms.TTerm [Syntax.FixedPointerDeclarator]
fixedStatementDeclarators x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedStatement"),
        Core.projectionField = (Core.Name "declarators")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

fixedStatementPointerType :: Phantoms.TTerm Syntax.FixedStatement -> Phantoms.TTerm Syntax.PointerType
fixedStatementPointerType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedStatement"),
        Core.projectionField = (Core.Name "pointerType")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

fixedStatementStatement :: Phantoms.TTerm Syntax.FixedStatement -> Phantoms.TTerm Syntax.EmbeddedStatement
fixedStatementStatement x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedStatement"),
        Core.projectionField = (Core.Name "statement")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

fixedStatementWithDeclarators :: Phantoms.TTerm Syntax.FixedStatement -> Phantoms.TTerm [Syntax.FixedPointerDeclarator] -> Phantoms.TTerm Syntax.FixedStatement
fixedStatementWithDeclarators original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FixedStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "pointerType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedStatement"),
              Core.projectionField = (Core.Name "pointerType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "statement"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedStatement"),
              Core.projectionField = (Core.Name "statement")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

fixedStatementWithPointerType :: Phantoms.TTerm Syntax.FixedStatement -> Phantoms.TTerm Syntax.PointerType -> Phantoms.TTerm Syntax.FixedStatement
fixedStatementWithPointerType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FixedStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "pointerType"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedStatement"),
              Core.projectionField = (Core.Name "declarators")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "statement"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedStatement"),
              Core.projectionField = (Core.Name "statement")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

fixedStatementWithStatement :: Phantoms.TTerm Syntax.FixedStatement -> Phantoms.TTerm Syntax.EmbeddedStatement -> Phantoms.TTerm Syntax.FixedStatement
fixedStatementWithStatement original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FixedStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "pointerType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedStatement"),
              Core.projectionField = (Core.Name "pointerType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FixedStatement"),
              Core.projectionField = (Core.Name "declarators")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "statement"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

floatingPointTypeDouble :: Phantoms.TTerm Syntax.FloatingPointType
floatingPointTypeDouble =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.FloatingPointType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "double"),
        Core.fieldTerm = Core.TermUnit}}))

floatingPointTypeFloat :: Phantoms.TTerm Syntax.FloatingPointType
floatingPointTypeFloat =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.FloatingPointType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "float"),
        Core.fieldTerm = Core.TermUnit}}))

forInitializerStatements :: Phantoms.TTerm Syntax.StatementExpressionList -> Phantoms.TTerm Syntax.ForInitializer
forInitializerStatements x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ForInitializer"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "statements"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

forInitializerVariable :: Phantoms.TTerm Syntax.LocalVariableDeclaration -> Phantoms.TTerm Syntax.ForInitializer
forInitializerVariable x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ForInitializer"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "variable"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

forStatement :: Phantoms.TTerm (Maybe Syntax.ForInitializer) -> Phantoms.TTerm (Maybe Syntax.BooleanExpression) -> Phantoms.TTerm (Maybe Syntax.StatementExpressionList) -> Phantoms.TTerm Syntax.EmbeddedStatement -> Phantoms.TTerm Syntax.ForStatement
forStatement initializer condition iterator body =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ForStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Phantoms.unTTerm initializer)},
        Core.Field {
          Core.fieldName = (Core.Name "condition"),
          Core.fieldTerm = (Phantoms.unTTerm condition)},
        Core.Field {
          Core.fieldName = (Core.Name "iterator"),
          Core.fieldTerm = (Phantoms.unTTerm iterator)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)}]}))

forStatementBody :: Phantoms.TTerm Syntax.ForStatement -> Phantoms.TTerm Syntax.EmbeddedStatement
forStatementBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForStatement"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

forStatementCondition :: Phantoms.TTerm Syntax.ForStatement -> Phantoms.TTerm (Maybe Syntax.BooleanExpression)
forStatementCondition x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForStatement"),
        Core.projectionField = (Core.Name "condition")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

forStatementInitializer :: Phantoms.TTerm Syntax.ForStatement -> Phantoms.TTerm (Maybe Syntax.ForInitializer)
forStatementInitializer x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForStatement"),
        Core.projectionField = (Core.Name "initializer")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

forStatementIterator :: Phantoms.TTerm Syntax.ForStatement -> Phantoms.TTerm (Maybe Syntax.StatementExpressionList)
forStatementIterator x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForStatement"),
        Core.projectionField = (Core.Name "iterator")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

forStatementWithBody :: Phantoms.TTerm Syntax.ForStatement -> Phantoms.TTerm Syntax.EmbeddedStatement -> Phantoms.TTerm Syntax.ForStatement
forStatementWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ForStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForStatement"),
              Core.projectionField = (Core.Name "initializer")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "condition"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForStatement"),
              Core.projectionField = (Core.Name "condition")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "iterator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForStatement"),
              Core.projectionField = (Core.Name "iterator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

forStatementWithCondition :: Phantoms.TTerm Syntax.ForStatement -> Phantoms.TTerm (Maybe Syntax.BooleanExpression) -> Phantoms.TTerm Syntax.ForStatement
forStatementWithCondition original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ForStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForStatement"),
              Core.projectionField = (Core.Name "initializer")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "condition"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "iterator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForStatement"),
              Core.projectionField = (Core.Name "iterator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForStatement"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

forStatementWithInitializer :: Phantoms.TTerm Syntax.ForStatement -> Phantoms.TTerm (Maybe Syntax.ForInitializer) -> Phantoms.TTerm Syntax.ForStatement
forStatementWithInitializer original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ForStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "condition"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForStatement"),
              Core.projectionField = (Core.Name "condition")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "iterator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForStatement"),
              Core.projectionField = (Core.Name "iterator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForStatement"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

forStatementWithIterator :: Phantoms.TTerm Syntax.ForStatement -> Phantoms.TTerm (Maybe Syntax.StatementExpressionList) -> Phantoms.TTerm Syntax.ForStatement
forStatementWithIterator original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ForStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForStatement"),
              Core.projectionField = (Core.Name "initializer")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "condition"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForStatement"),
              Core.projectionField = (Core.Name "condition")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "iterator"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForStatement"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

foreachStatement :: Phantoms.TTerm (Maybe Syntax.RefKind) -> Phantoms.TTerm Syntax.LocalVariableType -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.EmbeddedStatement -> Phantoms.TTerm Syntax.ForeachStatement
foreachStatement kind type_ identifier expression body =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ForeachStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "kind"),
          Core.fieldTerm = (Phantoms.unTTerm kind)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm identifier)},
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm expression)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)}]}))

foreachStatementBody :: Phantoms.TTerm Syntax.ForeachStatement -> Phantoms.TTerm Syntax.EmbeddedStatement
foreachStatementBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForeachStatement"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

foreachStatementExpression :: Phantoms.TTerm Syntax.ForeachStatement -> Phantoms.TTerm Syntax.Expression
foreachStatementExpression x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForeachStatement"),
        Core.projectionField = (Core.Name "expression")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

foreachStatementIdentifier :: Phantoms.TTerm Syntax.ForeachStatement -> Phantoms.TTerm Syntax.Identifier
foreachStatementIdentifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForeachStatement"),
        Core.projectionField = (Core.Name "identifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

foreachStatementKind :: Phantoms.TTerm Syntax.ForeachStatement -> Phantoms.TTerm (Maybe Syntax.RefKind)
foreachStatementKind x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForeachStatement"),
        Core.projectionField = (Core.Name "kind")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

foreachStatementType :: Phantoms.TTerm Syntax.ForeachStatement -> Phantoms.TTerm Syntax.LocalVariableType
foreachStatementType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForeachStatement"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

foreachStatementWithBody :: Phantoms.TTerm Syntax.ForeachStatement -> Phantoms.TTerm Syntax.EmbeddedStatement -> Phantoms.TTerm Syntax.ForeachStatement
foreachStatementWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ForeachStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "kind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForeachStatement"),
              Core.projectionField = (Core.Name "kind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForeachStatement"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForeachStatement"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForeachStatement"),
              Core.projectionField = (Core.Name "expression")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

foreachStatementWithExpression :: Phantoms.TTerm Syntax.ForeachStatement -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.ForeachStatement
foreachStatementWithExpression original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ForeachStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "kind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForeachStatement"),
              Core.projectionField = (Core.Name "kind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForeachStatement"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForeachStatement"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForeachStatement"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

foreachStatementWithIdentifier :: Phantoms.TTerm Syntax.ForeachStatement -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.ForeachStatement
foreachStatementWithIdentifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ForeachStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "kind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForeachStatement"),
              Core.projectionField = (Core.Name "kind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForeachStatement"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForeachStatement"),
              Core.projectionField = (Core.Name "expression")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForeachStatement"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

foreachStatementWithKind :: Phantoms.TTerm Syntax.ForeachStatement -> Phantoms.TTerm (Maybe Syntax.RefKind) -> Phantoms.TTerm Syntax.ForeachStatement
foreachStatementWithKind original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ForeachStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "kind"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForeachStatement"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForeachStatement"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForeachStatement"),
              Core.projectionField = (Core.Name "expression")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForeachStatement"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

foreachStatementWithType :: Phantoms.TTerm Syntax.ForeachStatement -> Phantoms.TTerm Syntax.LocalVariableType -> Phantoms.TTerm Syntax.ForeachStatement
foreachStatementWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ForeachStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "kind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForeachStatement"),
              Core.projectionField = (Core.Name "kind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForeachStatement"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForeachStatement"),
              Core.projectionField = (Core.Name "expression")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ForeachStatement"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

formalParameterList :: Phantoms.TTerm [Syntax.FixedParameter] -> Phantoms.TTerm (Maybe Syntax.ParameterArray) -> Phantoms.TTerm Syntax.FormalParameterList
formalParameterList fixed array =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FormalParameterList"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "fixed"),
          Core.fieldTerm = (Phantoms.unTTerm fixed)},
        Core.Field {
          Core.fieldName = (Core.Name "array"),
          Core.fieldTerm = (Phantoms.unTTerm array)}]}))

formalParameterListArray :: Phantoms.TTerm Syntax.FormalParameterList -> Phantoms.TTerm (Maybe Syntax.ParameterArray)
formalParameterListArray x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FormalParameterList"),
        Core.projectionField = (Core.Name "array")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

formalParameterListFixed :: Phantoms.TTerm Syntax.FormalParameterList -> Phantoms.TTerm [Syntax.FixedParameter]
formalParameterListFixed x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FormalParameterList"),
        Core.projectionField = (Core.Name "fixed")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

formalParameterListWithArray :: Phantoms.TTerm Syntax.FormalParameterList -> Phantoms.TTerm (Maybe Syntax.ParameterArray) -> Phantoms.TTerm Syntax.FormalParameterList
formalParameterListWithArray original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FormalParameterList"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "fixed"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FormalParameterList"),
              Core.projectionField = (Core.Name "fixed")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "array"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

formalParameterListWithFixed :: Phantoms.TTerm Syntax.FormalParameterList -> Phantoms.TTerm [Syntax.FixedParameter] -> Phantoms.TTerm Syntax.FormalParameterList
formalParameterListWithFixed original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FormalParameterList"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "fixed"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "array"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FormalParameterList"),
              Core.projectionField = (Core.Name "array")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

fromClause :: Phantoms.TTerm (Maybe Syntax.Type) -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.FromClause
fromClause type_ identifier in_ =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FromClause"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm identifier)},
        Core.Field {
          Core.fieldName = (Core.Name "in"),
          Core.fieldTerm = (Phantoms.unTTerm in_)}]}))

fromClauseIdentifier :: Phantoms.TTerm Syntax.FromClause -> Phantoms.TTerm Syntax.Identifier
fromClauseIdentifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FromClause"),
        Core.projectionField = (Core.Name "identifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

fromClauseIn :: Phantoms.TTerm Syntax.FromClause -> Phantoms.TTerm Syntax.Expression
fromClauseIn x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FromClause"),
        Core.projectionField = (Core.Name "in")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

fromClauseType :: Phantoms.TTerm Syntax.FromClause -> Phantoms.TTerm (Maybe Syntax.Type)
fromClauseType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FromClause"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

fromClauseWithIdentifier :: Phantoms.TTerm Syntax.FromClause -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.FromClause
fromClauseWithIdentifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FromClause"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FromClause"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "in"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FromClause"),
              Core.projectionField = (Core.Name "in")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

fromClauseWithIn :: Phantoms.TTerm Syntax.FromClause -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.FromClause
fromClauseWithIn original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FromClause"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FromClause"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FromClause"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "in"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

fromClauseWithType :: Phantoms.TTerm Syntax.FromClause -> Phantoms.TTerm (Maybe Syntax.Type) -> Phantoms.TTerm Syntax.FromClause
fromClauseWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.FromClause"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FromClause"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "in"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.FromClause"),
              Core.projectionField = (Core.Name "in")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

globalAttributeSection :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.AttributeList -> Phantoms.TTerm Syntax.GlobalAttributeSection
globalAttributeSection target attributes =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.GlobalAttributeSection"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "target"),
          Core.fieldTerm = (Phantoms.unTTerm target)},
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)}]}))

globalAttributeSectionAttributes :: Phantoms.TTerm Syntax.GlobalAttributeSection -> Phantoms.TTerm Syntax.AttributeList
globalAttributeSectionAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.GlobalAttributeSection"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

globalAttributeSectionTarget :: Phantoms.TTerm Syntax.GlobalAttributeSection -> Phantoms.TTerm Syntax.Identifier
globalAttributeSectionTarget x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.GlobalAttributeSection"),
        Core.projectionField = (Core.Name "target")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

globalAttributeSectionWithAttributes :: Phantoms.TTerm Syntax.GlobalAttributeSection -> Phantoms.TTerm Syntax.AttributeList -> Phantoms.TTerm Syntax.GlobalAttributeSection
globalAttributeSectionWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.GlobalAttributeSection"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "target"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.GlobalAttributeSection"),
              Core.projectionField = (Core.Name "target")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

globalAttributeSectionWithTarget :: Phantoms.TTerm Syntax.GlobalAttributeSection -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.GlobalAttributeSection
globalAttributeSectionWithTarget original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.GlobalAttributeSection"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "target"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.GlobalAttributeSection"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

gotoStatementCase :: Phantoms.TTerm Syntax.ConstantExpression -> Phantoms.TTerm Syntax.GotoStatement
gotoStatementCase x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.GotoStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "case"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

gotoStatementDefault :: Phantoms.TTerm Syntax.GotoStatement
gotoStatementDefault =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.GotoStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "default"),
        Core.fieldTerm = Core.TermUnit}}))

gotoStatementIdentifier :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.GotoStatement
gotoStatementIdentifier x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.GotoStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "identifier"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

groupClause :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.GroupClause
groupClause grouped by =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.GroupClause"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "grouped"),
          Core.fieldTerm = (Phantoms.unTTerm grouped)},
        Core.Field {
          Core.fieldName = (Core.Name "by"),
          Core.fieldTerm = (Phantoms.unTTerm by)}]}))

groupClauseBy :: Phantoms.TTerm Syntax.GroupClause -> Phantoms.TTerm Syntax.Expression
groupClauseBy x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.GroupClause"),
        Core.projectionField = (Core.Name "by")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

groupClauseGrouped :: Phantoms.TTerm Syntax.GroupClause -> Phantoms.TTerm Syntax.Expression
groupClauseGrouped x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.GroupClause"),
        Core.projectionField = (Core.Name "grouped")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

groupClauseWithBy :: Phantoms.TTerm Syntax.GroupClause -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.GroupClause
groupClauseWithBy original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.GroupClause"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "grouped"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.GroupClause"),
              Core.projectionField = (Core.Name "grouped")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "by"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

groupClauseWithGrouped :: Phantoms.TTerm Syntax.GroupClause -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.GroupClause
groupClauseWithGrouped original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.GroupClause"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "grouped"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "by"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.GroupClause"),
              Core.projectionField = (Core.Name "by")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

identifier :: Phantoms.TTerm String -> Phantoms.TTerm Syntax.Identifier
identifier x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.Identifier"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

identifierNamespaceOrTypeName :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList) -> Phantoms.TTerm Syntax.IdentifierNamespaceOrTypeName
identifierNamespaceOrTypeName identifier arguments =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.IdentifierNamespaceOrTypeName"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm identifier)},
        Core.Field {
          Core.fieldName = (Core.Name "arguments"),
          Core.fieldTerm = (Phantoms.unTTerm arguments)}]}))

identifierNamespaceOrTypeNameArguments :: Phantoms.TTerm Syntax.IdentifierNamespaceOrTypeName -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList)
identifierNamespaceOrTypeNameArguments x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.IdentifierNamespaceOrTypeName"),
        Core.projectionField = (Core.Name "arguments")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

identifierNamespaceOrTypeNameIdentifier :: Phantoms.TTerm Syntax.IdentifierNamespaceOrTypeName -> Phantoms.TTerm Syntax.Identifier
identifierNamespaceOrTypeNameIdentifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.IdentifierNamespaceOrTypeName"),
        Core.projectionField = (Core.Name "identifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

identifierNamespaceOrTypeNameWithArguments :: Phantoms.TTerm Syntax.IdentifierNamespaceOrTypeName -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList) -> Phantoms.TTerm Syntax.IdentifierNamespaceOrTypeName
identifierNamespaceOrTypeNameWithArguments original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.IdentifierNamespaceOrTypeName"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.IdentifierNamespaceOrTypeName"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "arguments"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

identifierNamespaceOrTypeNameWithIdentifier :: Phantoms.TTerm Syntax.IdentifierNamespaceOrTypeName -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.IdentifierNamespaceOrTypeName
identifierNamespaceOrTypeNameWithIdentifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.IdentifierNamespaceOrTypeName"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "arguments"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.IdentifierNamespaceOrTypeName"),
              Core.projectionField = (Core.Name "arguments")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

ifStatement :: Phantoms.TTerm Syntax.BooleanExpression -> Phantoms.TTerm Syntax.EmbeddedStatement -> Phantoms.TTerm Syntax.EmbeddedStatement -> Phantoms.TTerm Syntax.IfStatement
ifStatement condition ifBranch elseBranch =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.IfStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "condition"),
          Core.fieldTerm = (Phantoms.unTTerm condition)},
        Core.Field {
          Core.fieldName = (Core.Name "ifBranch"),
          Core.fieldTerm = (Phantoms.unTTerm ifBranch)},
        Core.Field {
          Core.fieldName = (Core.Name "elseBranch"),
          Core.fieldTerm = (Phantoms.unTTerm elseBranch)}]}))

ifStatementCondition :: Phantoms.TTerm Syntax.IfStatement -> Phantoms.TTerm Syntax.BooleanExpression
ifStatementCondition x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.IfStatement"),
        Core.projectionField = (Core.Name "condition")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

ifStatementElseBranch :: Phantoms.TTerm Syntax.IfStatement -> Phantoms.TTerm Syntax.EmbeddedStatement
ifStatementElseBranch x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.IfStatement"),
        Core.projectionField = (Core.Name "elseBranch")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

ifStatementIfBranch :: Phantoms.TTerm Syntax.IfStatement -> Phantoms.TTerm Syntax.EmbeddedStatement
ifStatementIfBranch x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.IfStatement"),
        Core.projectionField = (Core.Name "ifBranch")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

ifStatementWithCondition :: Phantoms.TTerm Syntax.IfStatement -> Phantoms.TTerm Syntax.BooleanExpression -> Phantoms.TTerm Syntax.IfStatement
ifStatementWithCondition original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.IfStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "condition"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "ifBranch"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.IfStatement"),
              Core.projectionField = (Core.Name "ifBranch")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "elseBranch"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.IfStatement"),
              Core.projectionField = (Core.Name "elseBranch")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

ifStatementWithElseBranch :: Phantoms.TTerm Syntax.IfStatement -> Phantoms.TTerm Syntax.EmbeddedStatement -> Phantoms.TTerm Syntax.IfStatement
ifStatementWithElseBranch original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.IfStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "condition"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.IfStatement"),
              Core.projectionField = (Core.Name "condition")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "ifBranch"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.IfStatement"),
              Core.projectionField = (Core.Name "ifBranch")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "elseBranch"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

ifStatementWithIfBranch :: Phantoms.TTerm Syntax.IfStatement -> Phantoms.TTerm Syntax.EmbeddedStatement -> Phantoms.TTerm Syntax.IfStatement
ifStatementWithIfBranch original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.IfStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "condition"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.IfStatement"),
              Core.projectionField = (Core.Name "condition")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "ifBranch"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "elseBranch"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.IfStatement"),
              Core.projectionField = (Core.Name "elseBranch")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

implicitlyTypedLocalVariableDeclarationRefVar :: Phantoms.TTerm Syntax.RefVarImplicitlyTypedLocalVariableDeclaration -> Phantoms.TTerm Syntax.ImplicitlyTypedLocalVariableDeclaration
implicitlyTypedLocalVariableDeclarationRefVar x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ImplicitlyTypedLocalVariableDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "refVar"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

implicitlyTypedLocalVariableDeclarationVar :: Phantoms.TTerm Syntax.ImplicitlyTypedLocalVariableDeclarator -> Phantoms.TTerm Syntax.ImplicitlyTypedLocalVariableDeclaration
implicitlyTypedLocalVariableDeclarationVar x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ImplicitlyTypedLocalVariableDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "var"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

implicitlyTypedLocalVariableDeclarator :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.ImplicitlyTypedLocalVariableDeclarator
implicitlyTypedLocalVariableDeclarator identifier expression =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm identifier)},
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm expression)}]}))

implicitlyTypedLocalVariableDeclaratorExpression :: Phantoms.TTerm Syntax.ImplicitlyTypedLocalVariableDeclarator -> Phantoms.TTerm Syntax.Expression
implicitlyTypedLocalVariableDeclaratorExpression x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator"),
        Core.projectionField = (Core.Name "expression")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

implicitlyTypedLocalVariableDeclaratorIdentifier :: Phantoms.TTerm Syntax.ImplicitlyTypedLocalVariableDeclarator -> Phantoms.TTerm Syntax.Identifier
implicitlyTypedLocalVariableDeclaratorIdentifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator"),
        Core.projectionField = (Core.Name "identifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

implicitlyTypedLocalVariableDeclaratorWithExpression :: Phantoms.TTerm Syntax.ImplicitlyTypedLocalVariableDeclarator -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.ImplicitlyTypedLocalVariableDeclarator
implicitlyTypedLocalVariableDeclaratorWithExpression original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

implicitlyTypedLocalVariableDeclaratorWithIdentifier :: Phantoms.TTerm Syntax.ImplicitlyTypedLocalVariableDeclarator -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.ImplicitlyTypedLocalVariableDeclarator
implicitlyTypedLocalVariableDeclaratorWithIdentifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ImplicitlyTypedLocalVariableDeclarator"),
              Core.projectionField = (Core.Name "expression")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

inclusiveOrExpressionBinary :: Phantoms.TTerm Syntax.BinaryInclusiveOrExpression -> Phantoms.TTerm Syntax.InclusiveOrExpression
inclusiveOrExpressionBinary x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.InclusiveOrExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "binary"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

inclusiveOrExpressionSimple :: Phantoms.TTerm Syntax.ExclusiveOrExpression -> Phantoms.TTerm Syntax.InclusiveOrExpression
inclusiveOrExpressionSimple x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.InclusiveOrExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "simple"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

indexerBodyBlock :: Phantoms.TTerm Syntax.AccessorDeclarations -> Phantoms.TTerm Syntax.IndexerBody
indexerBodyBlock x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.IndexerBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "block"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

indexerBodyExpression :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.IndexerBody
indexerBodyExpression x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.IndexerBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "expression"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

indexerDeclarationRef :: Phantoms.TTerm Syntax.RefIndexerDeclaration -> Phantoms.TTerm Syntax.IndexerDeclaration
indexerDeclarationRef x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.IndexerDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "ref"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

indexerDeclarationStandard :: Phantoms.TTerm Syntax.StandardIndexerDeclaration -> Phantoms.TTerm Syntax.IndexerDeclaration
indexerDeclarationStandard x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.IndexerDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "standard"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

indexerDeclarator :: Phantoms.TTerm Syntax.Type -> Phantoms.TTerm (Maybe Syntax.InterfaceType) -> Phantoms.TTerm Syntax.FormalParameterList -> Phantoms.TTerm Syntax.IndexerDeclarator
indexerDeclarator type_ interface parameters =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.IndexerDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "interface"),
          Core.fieldTerm = (Phantoms.unTTerm interface)},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Phantoms.unTTerm parameters)}]}))

indexerDeclaratorInterface :: Phantoms.TTerm Syntax.IndexerDeclarator -> Phantoms.TTerm (Maybe Syntax.InterfaceType)
indexerDeclaratorInterface x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.IndexerDeclarator"),
        Core.projectionField = (Core.Name "interface")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

indexerDeclaratorParameters :: Phantoms.TTerm Syntax.IndexerDeclarator -> Phantoms.TTerm Syntax.FormalParameterList
indexerDeclaratorParameters x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.IndexerDeclarator"),
        Core.projectionField = (Core.Name "parameters")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

indexerDeclaratorType :: Phantoms.TTerm Syntax.IndexerDeclarator -> Phantoms.TTerm Syntax.Type
indexerDeclaratorType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.IndexerDeclarator"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

indexerDeclaratorWithInterface :: Phantoms.TTerm Syntax.IndexerDeclarator -> Phantoms.TTerm (Maybe Syntax.InterfaceType) -> Phantoms.TTerm Syntax.IndexerDeclarator
indexerDeclaratorWithInterface original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.IndexerDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.IndexerDeclarator"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "interface"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.IndexerDeclarator"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

indexerDeclaratorWithParameters :: Phantoms.TTerm Syntax.IndexerDeclarator -> Phantoms.TTerm Syntax.FormalParameterList -> Phantoms.TTerm Syntax.IndexerDeclarator
indexerDeclaratorWithParameters original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.IndexerDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.IndexerDeclarator"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "interface"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.IndexerDeclarator"),
              Core.projectionField = (Core.Name "interface")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

indexerDeclaratorWithType :: Phantoms.TTerm Syntax.IndexerDeclarator -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.IndexerDeclarator
indexerDeclaratorWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.IndexerDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "interface"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.IndexerDeclarator"),
              Core.projectionField = (Core.Name "interface")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.IndexerDeclarator"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

indexerModifierAbstract :: Phantoms.TTerm Syntax.IndexerModifier
indexerModifierAbstract =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.IndexerModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "abstract"),
        Core.fieldTerm = Core.TermUnit}}))

indexerModifierExtern :: Phantoms.TTerm Syntax.IndexerModifier
indexerModifierExtern =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.IndexerModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "extern"),
        Core.fieldTerm = Core.TermUnit}}))

indexerModifierInternal :: Phantoms.TTerm Syntax.IndexerModifier
indexerModifierInternal =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.IndexerModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "internal"),
        Core.fieldTerm = Core.TermUnit}}))

indexerModifierNew :: Phantoms.TTerm Syntax.IndexerModifier
indexerModifierNew =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.IndexerModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "new"),
        Core.fieldTerm = Core.TermUnit}}))

indexerModifierOverride :: Phantoms.TTerm Syntax.IndexerModifier
indexerModifierOverride =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.IndexerModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "override"),
        Core.fieldTerm = Core.TermUnit}}))

indexerModifierPrivate :: Phantoms.TTerm Syntax.IndexerModifier
indexerModifierPrivate =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.IndexerModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "private"),
        Core.fieldTerm = Core.TermUnit}}))

indexerModifierProtected :: Phantoms.TTerm Syntax.IndexerModifier
indexerModifierProtected =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.IndexerModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "protected"),
        Core.fieldTerm = Core.TermUnit}}))

indexerModifierPublic :: Phantoms.TTerm Syntax.IndexerModifier
indexerModifierPublic =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.IndexerModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "public"),
        Core.fieldTerm = Core.TermUnit}}))

indexerModifierSealed :: Phantoms.TTerm Syntax.IndexerModifier
indexerModifierSealed =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.IndexerModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "sealed"),
        Core.fieldTerm = Core.TermUnit}}))

indexerModifierUnsafe :: Phantoms.TTerm Syntax.IndexerModifier
indexerModifierUnsafe =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.IndexerModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "unsafe"),
        Core.fieldTerm = Core.TermUnit}}))

indexerModifierVirtual :: Phantoms.TTerm Syntax.IndexerModifier
indexerModifierVirtual =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.IndexerModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "virtual"),
        Core.fieldTerm = Core.TermUnit}}))

initializerTargetArguments :: Phantoms.TTerm Syntax.ArgumentList -> Phantoms.TTerm Syntax.InitializerTarget
initializerTargetArguments x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.InitializerTarget"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "arguments"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

initializerTargetIdentifier :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.InitializerTarget
initializerTargetIdentifier x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.InitializerTarget"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "identifier"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

initializerValueExpression :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.InitializerValue
initializerValueExpression x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.InitializerValue"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "expression"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

initializerValueObjectOrCollection :: Phantoms.TTerm Syntax.ObjectOrCollectionInitializer -> Phantoms.TTerm Syntax.InitializerValue
initializerValueObjectOrCollection x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.InitializerValue"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "objectOrCollection"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

integerLiteralBinary :: Phantoms.TTerm Integer -> Phantoms.TTerm Syntax.IntegerLiteral
integerLiteralBinary x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.IntegerLiteral"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "binary"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

integerLiteralDecimal :: Phantoms.TTerm String -> Phantoms.TTerm Syntax.IntegerLiteral
integerLiteralDecimal x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.IntegerLiteral"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "decimal"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

integerLiteralHexadecimal :: Phantoms.TTerm String -> Phantoms.TTerm Syntax.IntegerLiteral
integerLiteralHexadecimal x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.IntegerLiteral"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "hexadecimal"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

integralTypeByte :: Phantoms.TTerm Syntax.IntegralType
integralTypeByte =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.IntegralType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "byte"),
        Core.fieldTerm = Core.TermUnit}}))

integralTypeChar :: Phantoms.TTerm Syntax.IntegralType
integralTypeChar =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.IntegralType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "char"),
        Core.fieldTerm = Core.TermUnit}}))

integralTypeInt :: Phantoms.TTerm Syntax.IntegralType
integralTypeInt =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.IntegralType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "int"),
        Core.fieldTerm = Core.TermUnit}}))

integralTypeLong :: Phantoms.TTerm Syntax.IntegralType
integralTypeLong =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.IntegralType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "long"),
        Core.fieldTerm = Core.TermUnit}}))

integralTypeSbyte :: Phantoms.TTerm Syntax.IntegralType
integralTypeSbyte =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.IntegralType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "sbyte"),
        Core.fieldTerm = Core.TermUnit}}))

integralTypeShort :: Phantoms.TTerm Syntax.IntegralType
integralTypeShort =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.IntegralType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "short"),
        Core.fieldTerm = Core.TermUnit}}))

integralTypeUint :: Phantoms.TTerm Syntax.IntegralType
integralTypeUint =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.IntegralType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "uint"),
        Core.fieldTerm = Core.TermUnit}}))

integralTypeUlong :: Phantoms.TTerm Syntax.IntegralType
integralTypeUlong =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.IntegralType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "ulong"),
        Core.fieldTerm = Core.TermUnit}}))

integralTypeUshort :: Phantoms.TTerm Syntax.IntegralType
integralTypeUshort =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.IntegralType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "ushort"),
        Core.fieldTerm = Core.TermUnit}}))

interfaceAccessors :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.InterfaceAccessors
interfaceAccessors attributes get set =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceAccessors"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "get"),
          Core.fieldTerm = (Phantoms.unTTerm get)},
        Core.Field {
          Core.fieldName = (Core.Name "set"),
          Core.fieldTerm = (Phantoms.unTTerm set)}]}))

interfaceAccessorsAttributes :: Phantoms.TTerm Syntax.InterfaceAccessors -> Phantoms.TTerm (Maybe Syntax.Attributes)
interfaceAccessorsAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceAccessors"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfaceAccessorsGet :: Phantoms.TTerm Syntax.InterfaceAccessors -> Phantoms.TTerm (Maybe Syntax.Attributes)
interfaceAccessorsGet x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceAccessors"),
        Core.projectionField = (Core.Name "get")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfaceAccessorsSet :: Phantoms.TTerm Syntax.InterfaceAccessors -> Phantoms.TTerm (Maybe Syntax.Attributes)
interfaceAccessorsSet x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceAccessors"),
        Core.projectionField = (Core.Name "set")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfaceAccessorsWithAttributes :: Phantoms.TTerm Syntax.InterfaceAccessors -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.InterfaceAccessors
interfaceAccessorsWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceAccessors"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "get"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceAccessors"),
              Core.projectionField = (Core.Name "get")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "set"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceAccessors"),
              Core.projectionField = (Core.Name "set")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

interfaceAccessorsWithGet :: Phantoms.TTerm Syntax.InterfaceAccessors -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.InterfaceAccessors
interfaceAccessorsWithGet original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceAccessors"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceAccessors"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "get"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "set"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceAccessors"),
              Core.projectionField = (Core.Name "set")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

interfaceAccessorsWithSet :: Phantoms.TTerm Syntax.InterfaceAccessors -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.InterfaceAccessors
interfaceAccessorsWithSet original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceAccessors"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceAccessors"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "get"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceAccessors"),
              Core.projectionField = (Core.Name "get")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "set"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

interfaceDeclaration :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm [Syntax.InterfaceModifier] -> Phantoms.TTerm Bool -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm (Maybe Syntax.VariantTypeParameters) -> Phantoms.TTerm [Syntax.InterfaceType] -> Phantoms.TTerm [Syntax.TypeParameterConstraintsClause] -> Phantoms.TTerm [Syntax.InterfaceMemberDeclaration] -> Phantoms.TTerm Syntax.InterfaceDeclaration
interfaceDeclaration attributes modifiers partial name parameters base constraints body =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm modifiers)},
        Core.Field {
          Core.fieldName = (Core.Name "partial"),
          Core.fieldTerm = (Phantoms.unTTerm partial)},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm name)},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Phantoms.unTTerm parameters)},
        Core.Field {
          Core.fieldName = (Core.Name "base"),
          Core.fieldTerm = (Phantoms.unTTerm base)},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Phantoms.unTTerm constraints)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)}]}))

interfaceDeclarationAttributes :: Phantoms.TTerm Syntax.InterfaceDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes)
interfaceDeclarationAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfaceDeclarationBase :: Phantoms.TTerm Syntax.InterfaceDeclaration -> Phantoms.TTerm [Syntax.InterfaceType]
interfaceDeclarationBase x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
        Core.projectionField = (Core.Name "base")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfaceDeclarationBody :: Phantoms.TTerm Syntax.InterfaceDeclaration -> Phantoms.TTerm [Syntax.InterfaceMemberDeclaration]
interfaceDeclarationBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfaceDeclarationConstraints :: Phantoms.TTerm Syntax.InterfaceDeclaration -> Phantoms.TTerm [Syntax.TypeParameterConstraintsClause]
interfaceDeclarationConstraints x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
        Core.projectionField = (Core.Name "constraints")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfaceDeclarationModifiers :: Phantoms.TTerm Syntax.InterfaceDeclaration -> Phantoms.TTerm [Syntax.InterfaceModifier]
interfaceDeclarationModifiers x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
        Core.projectionField = (Core.Name "modifiers")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfaceDeclarationName :: Phantoms.TTerm Syntax.InterfaceDeclaration -> Phantoms.TTerm Syntax.Identifier
interfaceDeclarationName x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
        Core.projectionField = (Core.Name "name")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfaceDeclarationParameters :: Phantoms.TTerm Syntax.InterfaceDeclaration -> Phantoms.TTerm (Maybe Syntax.VariantTypeParameters)
interfaceDeclarationParameters x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
        Core.projectionField = (Core.Name "parameters")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfaceDeclarationPartial :: Phantoms.TTerm Syntax.InterfaceDeclaration -> Phantoms.TTerm Bool
interfaceDeclarationPartial x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
        Core.projectionField = (Core.Name "partial")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfaceDeclarationWithAttributes :: Phantoms.TTerm Syntax.InterfaceDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.InterfaceDeclaration
interfaceDeclarationWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "partial"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "partial")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "base"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "base")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

interfaceDeclarationWithBase :: Phantoms.TTerm Syntax.InterfaceDeclaration -> Phantoms.TTerm [Syntax.InterfaceType] -> Phantoms.TTerm Syntax.InterfaceDeclaration
interfaceDeclarationWithBase original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "partial"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "partial")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "base"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

interfaceDeclarationWithBody :: Phantoms.TTerm Syntax.InterfaceDeclaration -> Phantoms.TTerm [Syntax.InterfaceMemberDeclaration] -> Phantoms.TTerm Syntax.InterfaceDeclaration
interfaceDeclarationWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "partial"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "partial")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "base"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "base")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

interfaceDeclarationWithConstraints :: Phantoms.TTerm Syntax.InterfaceDeclaration -> Phantoms.TTerm [Syntax.TypeParameterConstraintsClause] -> Phantoms.TTerm Syntax.InterfaceDeclaration
interfaceDeclarationWithConstraints original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "partial"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "partial")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "base"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "base")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

interfaceDeclarationWithModifiers :: Phantoms.TTerm Syntax.InterfaceDeclaration -> Phantoms.TTerm [Syntax.InterfaceModifier] -> Phantoms.TTerm Syntax.InterfaceDeclaration
interfaceDeclarationWithModifiers original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "partial"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "partial")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "base"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "base")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

interfaceDeclarationWithName :: Phantoms.TTerm Syntax.InterfaceDeclaration -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.InterfaceDeclaration
interfaceDeclarationWithName original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "partial"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "partial")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "base"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "base")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

interfaceDeclarationWithParameters :: Phantoms.TTerm Syntax.InterfaceDeclaration -> Phantoms.TTerm (Maybe Syntax.VariantTypeParameters) -> Phantoms.TTerm Syntax.InterfaceDeclaration
interfaceDeclarationWithParameters original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "partial"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "partial")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "base"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "base")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

interfaceDeclarationWithPartial :: Phantoms.TTerm Syntax.InterfaceDeclaration -> Phantoms.TTerm Bool -> Phantoms.TTerm Syntax.InterfaceDeclaration
interfaceDeclarationWithPartial original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "partial"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "base"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "base")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

interfaceEventDeclaration :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Bool -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.InterfaceEventDeclaration
interfaceEventDeclaration attributes new type_ name =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceEventDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "new"),
          Core.fieldTerm = (Phantoms.unTTerm new)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm name)}]}))

interfaceEventDeclarationAttributes :: Phantoms.TTerm Syntax.InterfaceEventDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes)
interfaceEventDeclarationAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceEventDeclaration"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfaceEventDeclarationName :: Phantoms.TTerm Syntax.InterfaceEventDeclaration -> Phantoms.TTerm Syntax.Identifier
interfaceEventDeclarationName x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceEventDeclaration"),
        Core.projectionField = (Core.Name "name")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfaceEventDeclarationNew :: Phantoms.TTerm Syntax.InterfaceEventDeclaration -> Phantoms.TTerm Bool
interfaceEventDeclarationNew x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceEventDeclaration"),
        Core.projectionField = (Core.Name "new")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfaceEventDeclarationType :: Phantoms.TTerm Syntax.InterfaceEventDeclaration -> Phantoms.TTerm Syntax.Type
interfaceEventDeclarationType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceEventDeclaration"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfaceEventDeclarationWithAttributes :: Phantoms.TTerm Syntax.InterfaceEventDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.InterfaceEventDeclaration
interfaceEventDeclarationWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceEventDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "new"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceEventDeclaration"),
              Core.projectionField = (Core.Name "new")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceEventDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceEventDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

interfaceEventDeclarationWithName :: Phantoms.TTerm Syntax.InterfaceEventDeclaration -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.InterfaceEventDeclaration
interfaceEventDeclarationWithName original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceEventDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceEventDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "new"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceEventDeclaration"),
              Core.projectionField = (Core.Name "new")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceEventDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

interfaceEventDeclarationWithNew :: Phantoms.TTerm Syntax.InterfaceEventDeclaration -> Phantoms.TTerm Bool -> Phantoms.TTerm Syntax.InterfaceEventDeclaration
interfaceEventDeclarationWithNew original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceEventDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceEventDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "new"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceEventDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceEventDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

interfaceEventDeclarationWithType :: Phantoms.TTerm Syntax.InterfaceEventDeclaration -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.InterfaceEventDeclaration
interfaceEventDeclarationWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceEventDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceEventDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "new"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceEventDeclaration"),
              Core.projectionField = (Core.Name "new")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceEventDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

interfaceIndexerDeclaration :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Bool -> Phantoms.TTerm (Maybe Syntax.RefKind) -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.FormalParameterList -> Phantoms.TTerm Syntax.InterfaceAccessors -> Phantoms.TTerm Syntax.InterfaceIndexerDeclaration
interfaceIndexerDeclaration attributes new refKind type_ parameters accessors =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "new"),
          Core.fieldTerm = (Phantoms.unTTerm new)},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Phantoms.unTTerm refKind)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Phantoms.unTTerm parameters)},
        Core.Field {
          Core.fieldName = (Core.Name "accessors"),
          Core.fieldTerm = (Phantoms.unTTerm accessors)}]}))

interfaceIndexerDeclarationAccessors :: Phantoms.TTerm Syntax.InterfaceIndexerDeclaration -> Phantoms.TTerm Syntax.InterfaceAccessors
interfaceIndexerDeclarationAccessors x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
        Core.projectionField = (Core.Name "accessors")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfaceIndexerDeclarationAttributes :: Phantoms.TTerm Syntax.InterfaceIndexerDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes)
interfaceIndexerDeclarationAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfaceIndexerDeclarationNew :: Phantoms.TTerm Syntax.InterfaceIndexerDeclaration -> Phantoms.TTerm Bool
interfaceIndexerDeclarationNew x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
        Core.projectionField = (Core.Name "new")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfaceIndexerDeclarationParameters :: Phantoms.TTerm Syntax.InterfaceIndexerDeclaration -> Phantoms.TTerm Syntax.FormalParameterList
interfaceIndexerDeclarationParameters x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
        Core.projectionField = (Core.Name "parameters")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfaceIndexerDeclarationRefKind :: Phantoms.TTerm Syntax.InterfaceIndexerDeclaration -> Phantoms.TTerm (Maybe Syntax.RefKind)
interfaceIndexerDeclarationRefKind x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
        Core.projectionField = (Core.Name "refKind")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfaceIndexerDeclarationType :: Phantoms.TTerm Syntax.InterfaceIndexerDeclaration -> Phantoms.TTerm Syntax.Type
interfaceIndexerDeclarationType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfaceIndexerDeclarationWithAccessors :: Phantoms.TTerm Syntax.InterfaceIndexerDeclaration -> Phantoms.TTerm Syntax.InterfaceAccessors -> Phantoms.TTerm Syntax.InterfaceIndexerDeclaration
interfaceIndexerDeclarationWithAccessors original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "new"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
              Core.projectionField = (Core.Name "new")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "accessors"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

interfaceIndexerDeclarationWithAttributes :: Phantoms.TTerm Syntax.InterfaceIndexerDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.InterfaceIndexerDeclaration
interfaceIndexerDeclarationWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "new"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
              Core.projectionField = (Core.Name "new")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "accessors"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
              Core.projectionField = (Core.Name "accessors")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

interfaceIndexerDeclarationWithNew :: Phantoms.TTerm Syntax.InterfaceIndexerDeclaration -> Phantoms.TTerm Bool -> Phantoms.TTerm Syntax.InterfaceIndexerDeclaration
interfaceIndexerDeclarationWithNew original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "new"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "accessors"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
              Core.projectionField = (Core.Name "accessors")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

interfaceIndexerDeclarationWithParameters :: Phantoms.TTerm Syntax.InterfaceIndexerDeclaration -> Phantoms.TTerm Syntax.FormalParameterList -> Phantoms.TTerm Syntax.InterfaceIndexerDeclaration
interfaceIndexerDeclarationWithParameters original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "new"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
              Core.projectionField = (Core.Name "new")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "accessors"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
              Core.projectionField = (Core.Name "accessors")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

interfaceIndexerDeclarationWithRefKind :: Phantoms.TTerm Syntax.InterfaceIndexerDeclaration -> Phantoms.TTerm (Maybe Syntax.RefKind) -> Phantoms.TTerm Syntax.InterfaceIndexerDeclaration
interfaceIndexerDeclarationWithRefKind original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "new"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
              Core.projectionField = (Core.Name "new")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "accessors"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
              Core.projectionField = (Core.Name "accessors")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

interfaceIndexerDeclarationWithType :: Phantoms.TTerm Syntax.InterfaceIndexerDeclaration -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.InterfaceIndexerDeclaration
interfaceIndexerDeclarationWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "new"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
              Core.projectionField = (Core.Name "new")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "accessors"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceIndexerDeclaration"),
              Core.projectionField = (Core.Name "accessors")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

interfaceMemberDeclarationEvent :: Phantoms.TTerm Syntax.InterfaceEventDeclaration -> Phantoms.TTerm Syntax.InterfaceMemberDeclaration
interfaceMemberDeclarationEvent x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMemberDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "event"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

interfaceMemberDeclarationIndexer :: Phantoms.TTerm Syntax.InterfaceIndexerDeclaration -> Phantoms.TTerm Syntax.InterfaceMemberDeclaration
interfaceMemberDeclarationIndexer x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMemberDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "indexer"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

interfaceMemberDeclarationMethod :: Phantoms.TTerm Syntax.InterfaceMethodDeclaration -> Phantoms.TTerm Syntax.InterfaceMemberDeclaration
interfaceMemberDeclarationMethod x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMemberDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "method"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

interfaceMemberDeclarationProperty :: Phantoms.TTerm Syntax.InterfacePropertyDeclaration -> Phantoms.TTerm Syntax.InterfaceMemberDeclaration
interfaceMemberDeclarationProperty x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMemberDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "property"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

interfaceMethodDeclaration :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Bool -> Phantoms.TTerm Syntax.ReturnType -> Phantoms.TTerm (Maybe Syntax.RefKind) -> Phantoms.TTerm Syntax.InterfaceMethodHeader -> Phantoms.TTerm Syntax.InterfaceMethodDeclaration
interfaceMethodDeclaration attributes new returnType refKind header =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "new"),
          Core.fieldTerm = (Phantoms.unTTerm new)},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Phantoms.unTTerm returnType)},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Phantoms.unTTerm refKind)},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Phantoms.unTTerm header)}]}))

interfaceMethodDeclarationAttributes :: Phantoms.TTerm Syntax.InterfaceMethodDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes)
interfaceMethodDeclarationAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfaceMethodDeclarationHeader :: Phantoms.TTerm Syntax.InterfaceMethodDeclaration -> Phantoms.TTerm Syntax.InterfaceMethodHeader
interfaceMethodDeclarationHeader x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration"),
        Core.projectionField = (Core.Name "header")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfaceMethodDeclarationNew :: Phantoms.TTerm Syntax.InterfaceMethodDeclaration -> Phantoms.TTerm Bool
interfaceMethodDeclarationNew x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration"),
        Core.projectionField = (Core.Name "new")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfaceMethodDeclarationRefKind :: Phantoms.TTerm Syntax.InterfaceMethodDeclaration -> Phantoms.TTerm (Maybe Syntax.RefKind)
interfaceMethodDeclarationRefKind x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration"),
        Core.projectionField = (Core.Name "refKind")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfaceMethodDeclarationReturnType :: Phantoms.TTerm Syntax.InterfaceMethodDeclaration -> Phantoms.TTerm Syntax.ReturnType
interfaceMethodDeclarationReturnType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration"),
        Core.projectionField = (Core.Name "returnType")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfaceMethodDeclarationWithAttributes :: Phantoms.TTerm Syntax.InterfaceMethodDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.InterfaceMethodDeclaration
interfaceMethodDeclarationWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "new"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration"),
              Core.projectionField = (Core.Name "new")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration"),
              Core.projectionField = (Core.Name "returnType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration"),
              Core.projectionField = (Core.Name "header")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

interfaceMethodDeclarationWithHeader :: Phantoms.TTerm Syntax.InterfaceMethodDeclaration -> Phantoms.TTerm Syntax.InterfaceMethodHeader -> Phantoms.TTerm Syntax.InterfaceMethodDeclaration
interfaceMethodDeclarationWithHeader original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "new"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration"),
              Core.projectionField = (Core.Name "new")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration"),
              Core.projectionField = (Core.Name "returnType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

interfaceMethodDeclarationWithNew :: Phantoms.TTerm Syntax.InterfaceMethodDeclaration -> Phantoms.TTerm Bool -> Phantoms.TTerm Syntax.InterfaceMethodDeclaration
interfaceMethodDeclarationWithNew original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "new"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration"),
              Core.projectionField = (Core.Name "returnType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration"),
              Core.projectionField = (Core.Name "header")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

interfaceMethodDeclarationWithRefKind :: Phantoms.TTerm Syntax.InterfaceMethodDeclaration -> Phantoms.TTerm (Maybe Syntax.RefKind) -> Phantoms.TTerm Syntax.InterfaceMethodDeclaration
interfaceMethodDeclarationWithRefKind original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "new"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration"),
              Core.projectionField = (Core.Name "new")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration"),
              Core.projectionField = (Core.Name "returnType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration"),
              Core.projectionField = (Core.Name "header")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

interfaceMethodDeclarationWithReturnType :: Phantoms.TTerm Syntax.InterfaceMethodDeclaration -> Phantoms.TTerm Syntax.ReturnType -> Phantoms.TTerm Syntax.InterfaceMethodDeclaration
interfaceMethodDeclarationWithReturnType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "new"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration"),
              Core.projectionField = (Core.Name "new")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodDeclaration"),
              Core.projectionField = (Core.Name "header")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

interfaceMethodHeader :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm (Maybe Syntax.FormalParameterList) -> Phantoms.TTerm (Maybe Syntax.TypeParameterList) -> Phantoms.TTerm [Syntax.TypeParameterConstraintsClause] -> Phantoms.TTerm Syntax.InterfaceMethodHeader
interfaceMethodHeader name parameters typeParameters constraints =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodHeader"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm name)},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Phantoms.unTTerm parameters)},
        Core.Field {
          Core.fieldName = (Core.Name "typeParameters"),
          Core.fieldTerm = (Phantoms.unTTerm typeParameters)},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Phantoms.unTTerm constraints)}]}))

interfaceMethodHeaderConstraints :: Phantoms.TTerm Syntax.InterfaceMethodHeader -> Phantoms.TTerm [Syntax.TypeParameterConstraintsClause]
interfaceMethodHeaderConstraints x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodHeader"),
        Core.projectionField = (Core.Name "constraints")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfaceMethodHeaderName :: Phantoms.TTerm Syntax.InterfaceMethodHeader -> Phantoms.TTerm Syntax.Identifier
interfaceMethodHeaderName x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodHeader"),
        Core.projectionField = (Core.Name "name")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfaceMethodHeaderParameters :: Phantoms.TTerm Syntax.InterfaceMethodHeader -> Phantoms.TTerm (Maybe Syntax.FormalParameterList)
interfaceMethodHeaderParameters x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodHeader"),
        Core.projectionField = (Core.Name "parameters")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfaceMethodHeaderTypeParameters :: Phantoms.TTerm Syntax.InterfaceMethodHeader -> Phantoms.TTerm (Maybe Syntax.TypeParameterList)
interfaceMethodHeaderTypeParameters x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodHeader"),
        Core.projectionField = (Core.Name "typeParameters")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfaceMethodHeaderWithConstraints :: Phantoms.TTerm Syntax.InterfaceMethodHeader -> Phantoms.TTerm [Syntax.TypeParameterConstraintsClause] -> Phantoms.TTerm Syntax.InterfaceMethodHeader
interfaceMethodHeaderWithConstraints original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodHeader"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodHeader"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodHeader"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "typeParameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodHeader"),
              Core.projectionField = (Core.Name "typeParameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

interfaceMethodHeaderWithName :: Phantoms.TTerm Syntax.InterfaceMethodHeader -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.InterfaceMethodHeader
interfaceMethodHeaderWithName original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodHeader"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodHeader"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "typeParameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodHeader"),
              Core.projectionField = (Core.Name "typeParameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodHeader"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

interfaceMethodHeaderWithParameters :: Phantoms.TTerm Syntax.InterfaceMethodHeader -> Phantoms.TTerm (Maybe Syntax.FormalParameterList) -> Phantoms.TTerm Syntax.InterfaceMethodHeader
interfaceMethodHeaderWithParameters original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodHeader"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodHeader"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "typeParameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodHeader"),
              Core.projectionField = (Core.Name "typeParameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodHeader"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

interfaceMethodHeaderWithTypeParameters :: Phantoms.TTerm Syntax.InterfaceMethodHeader -> Phantoms.TTerm (Maybe Syntax.TypeParameterList) -> Phantoms.TTerm Syntax.InterfaceMethodHeader
interfaceMethodHeaderWithTypeParameters original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodHeader"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodHeader"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodHeader"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "typeParameters"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceMethodHeader"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

interfaceModifierInternal :: Phantoms.TTerm Syntax.InterfaceModifier
interfaceModifierInternal =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "internal"),
        Core.fieldTerm = Core.TermUnit}}))

interfaceModifierNew :: Phantoms.TTerm Syntax.InterfaceModifier
interfaceModifierNew =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "new"),
        Core.fieldTerm = Core.TermUnit}}))

interfaceModifierPrivate :: Phantoms.TTerm Syntax.InterfaceModifier
interfaceModifierPrivate =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "private"),
        Core.fieldTerm = Core.TermUnit}}))

interfaceModifierProtected :: Phantoms.TTerm Syntax.InterfaceModifier
interfaceModifierProtected =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "protected"),
        Core.fieldTerm = Core.TermUnit}}))

interfaceModifierPublic :: Phantoms.TTerm Syntax.InterfaceModifier
interfaceModifierPublic =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "public"),
        Core.fieldTerm = Core.TermUnit}}))

interfaceModifierUnsafe :: Phantoms.TTerm Syntax.InterfaceModifier
interfaceModifierUnsafe =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.InterfaceModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "unsafe"),
        Core.fieldTerm = Core.TermUnit}}))

interfacePropertyDeclaration :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Bool -> Phantoms.TTerm (Maybe Syntax.RefKind) -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.InterfaceAccessors -> Phantoms.TTerm Syntax.InterfacePropertyDeclaration
interfacePropertyDeclaration attributes new refKind type_ name accessors =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "new"),
          Core.fieldTerm = (Phantoms.unTTerm new)},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Phantoms.unTTerm refKind)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm name)},
        Core.Field {
          Core.fieldName = (Core.Name "accessors"),
          Core.fieldTerm = (Phantoms.unTTerm accessors)}]}))

interfacePropertyDeclarationAccessors :: Phantoms.TTerm Syntax.InterfacePropertyDeclaration -> Phantoms.TTerm Syntax.InterfaceAccessors
interfacePropertyDeclarationAccessors x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
        Core.projectionField = (Core.Name "accessors")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfacePropertyDeclarationAttributes :: Phantoms.TTerm Syntax.InterfacePropertyDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes)
interfacePropertyDeclarationAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfacePropertyDeclarationName :: Phantoms.TTerm Syntax.InterfacePropertyDeclaration -> Phantoms.TTerm Syntax.Identifier
interfacePropertyDeclarationName x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
        Core.projectionField = (Core.Name "name")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfacePropertyDeclarationNew :: Phantoms.TTerm Syntax.InterfacePropertyDeclaration -> Phantoms.TTerm Bool
interfacePropertyDeclarationNew x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
        Core.projectionField = (Core.Name "new")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfacePropertyDeclarationRefKind :: Phantoms.TTerm Syntax.InterfacePropertyDeclaration -> Phantoms.TTerm (Maybe Syntax.RefKind)
interfacePropertyDeclarationRefKind x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
        Core.projectionField = (Core.Name "refKind")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfacePropertyDeclarationType :: Phantoms.TTerm Syntax.InterfacePropertyDeclaration -> Phantoms.TTerm Syntax.Type
interfacePropertyDeclarationType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

interfacePropertyDeclarationWithAccessors :: Phantoms.TTerm Syntax.InterfacePropertyDeclaration -> Phantoms.TTerm Syntax.InterfaceAccessors -> Phantoms.TTerm Syntax.InterfacePropertyDeclaration
interfacePropertyDeclarationWithAccessors original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "new"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
              Core.projectionField = (Core.Name "new")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "accessors"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

interfacePropertyDeclarationWithAttributes :: Phantoms.TTerm Syntax.InterfacePropertyDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.InterfacePropertyDeclaration
interfacePropertyDeclarationWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "new"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
              Core.projectionField = (Core.Name "new")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "accessors"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
              Core.projectionField = (Core.Name "accessors")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

interfacePropertyDeclarationWithName :: Phantoms.TTerm Syntax.InterfacePropertyDeclaration -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.InterfacePropertyDeclaration
interfacePropertyDeclarationWithName original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "new"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
              Core.projectionField = (Core.Name "new")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "accessors"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
              Core.projectionField = (Core.Name "accessors")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

interfacePropertyDeclarationWithNew :: Phantoms.TTerm Syntax.InterfacePropertyDeclaration -> Phantoms.TTerm Bool -> Phantoms.TTerm Syntax.InterfacePropertyDeclaration
interfacePropertyDeclarationWithNew original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "new"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "accessors"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
              Core.projectionField = (Core.Name "accessors")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

interfacePropertyDeclarationWithRefKind :: Phantoms.TTerm Syntax.InterfacePropertyDeclaration -> Phantoms.TTerm (Maybe Syntax.RefKind) -> Phantoms.TTerm Syntax.InterfacePropertyDeclaration
interfacePropertyDeclarationWithRefKind original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "new"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
              Core.projectionField = (Core.Name "new")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "accessors"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
              Core.projectionField = (Core.Name "accessors")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

interfacePropertyDeclarationWithType :: Phantoms.TTerm Syntax.InterfacePropertyDeclaration -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.InterfacePropertyDeclaration
interfacePropertyDeclarationWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "new"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
              Core.projectionField = (Core.Name "new")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "accessors"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InterfacePropertyDeclaration"),
              Core.projectionField = (Core.Name "accessors")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

interfaceType :: Phantoms.TTerm Syntax.TypeName -> Phantoms.TTerm Syntax.InterfaceType
interfaceType x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.InterfaceType"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

interpolatedRegularStringExpression :: Phantoms.TTerm String -> Phantoms.TTerm Syntax.InterpolatedRegularStringExpression
interpolatedRegularStringExpression x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.InterpolatedRegularStringExpression"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

interpolatedStringExpressionRegular :: Phantoms.TTerm Syntax.InterpolatedRegularStringExpression -> Phantoms.TTerm Syntax.InterpolatedStringExpression
interpolatedStringExpressionRegular x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.InterpolatedStringExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "regular"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

interpolatedStringExpressionVerbatim :: Phantoms.TTerm Syntax.InterpolatedVerbatimStringExpression -> Phantoms.TTerm Syntax.InterpolatedStringExpression
interpolatedStringExpressionVerbatim x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.InterpolatedStringExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "verbatim"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

interpolatedVerbatimStringExpression :: Phantoms.TTerm String -> Phantoms.TTerm Syntax.InterpolatedVerbatimStringExpression
interpolatedVerbatimStringExpression x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.InterpolatedVerbatimStringExpression"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

invocationExpression :: Phantoms.TTerm Syntax.PrimaryExpression -> Phantoms.TTerm (Maybe Syntax.ArgumentList) -> Phantoms.TTerm Syntax.InvocationExpression
invocationExpression expression arguments =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InvocationExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm expression)},
        Core.Field {
          Core.fieldName = (Core.Name "arguments"),
          Core.fieldTerm = (Phantoms.unTTerm arguments)}]}))

invocationExpressionArguments :: Phantoms.TTerm Syntax.InvocationExpression -> Phantoms.TTerm (Maybe Syntax.ArgumentList)
invocationExpressionArguments x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InvocationExpression"),
        Core.projectionField = (Core.Name "arguments")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

invocationExpressionExpression :: Phantoms.TTerm Syntax.InvocationExpression -> Phantoms.TTerm Syntax.PrimaryExpression
invocationExpressionExpression x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InvocationExpression"),
        Core.projectionField = (Core.Name "expression")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

invocationExpressionWithArguments :: Phantoms.TTerm Syntax.InvocationExpression -> Phantoms.TTerm (Maybe Syntax.ArgumentList) -> Phantoms.TTerm Syntax.InvocationExpression
invocationExpressionWithArguments original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InvocationExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InvocationExpression"),
              Core.projectionField = (Core.Name "expression")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "arguments"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

invocationExpressionWithExpression :: Phantoms.TTerm Syntax.InvocationExpression -> Phantoms.TTerm Syntax.PrimaryExpression -> Phantoms.TTerm Syntax.InvocationExpression
invocationExpressionWithExpression original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.InvocationExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "arguments"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.InvocationExpression"),
              Core.projectionField = (Core.Name "arguments")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

isPatternExpression :: Phantoms.TTerm Syntax.RelationalExpression -> Phantoms.TTerm Syntax.Pattern -> Phantoms.TTerm Syntax.IsPatternExpression
isPatternExpression expression pattern =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.IsPatternExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm expression)},
        Core.Field {
          Core.fieldName = (Core.Name "pattern"),
          Core.fieldTerm = (Phantoms.unTTerm pattern)}]}))

isPatternExpressionExpression :: Phantoms.TTerm Syntax.IsPatternExpression -> Phantoms.TTerm Syntax.RelationalExpression
isPatternExpressionExpression x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.IsPatternExpression"),
        Core.projectionField = (Core.Name "expression")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

isPatternExpressionPattern :: Phantoms.TTerm Syntax.IsPatternExpression -> Phantoms.TTerm Syntax.Pattern
isPatternExpressionPattern x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.IsPatternExpression"),
        Core.projectionField = (Core.Name "pattern")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

isPatternExpressionWithExpression :: Phantoms.TTerm Syntax.IsPatternExpression -> Phantoms.TTerm Syntax.RelationalExpression -> Phantoms.TTerm Syntax.IsPatternExpression
isPatternExpressionWithExpression original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.IsPatternExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "pattern"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.IsPatternExpression"),
              Core.projectionField = (Core.Name "pattern")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

isPatternExpressionWithPattern :: Phantoms.TTerm Syntax.IsPatternExpression -> Phantoms.TTerm Syntax.Pattern -> Phantoms.TTerm Syntax.IsPatternExpression
isPatternExpressionWithPattern original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.IsPatternExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.IsPatternExpression"),
              Core.projectionField = (Core.Name "expression")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "pattern"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

isTypeExpression :: Phantoms.TTerm Syntax.RelationalExpression -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.IsTypeExpression
isTypeExpression expression type_ =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.IsTypeExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm expression)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)}]}))

isTypeExpressionExpression :: Phantoms.TTerm Syntax.IsTypeExpression -> Phantoms.TTerm Syntax.RelationalExpression
isTypeExpressionExpression x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.IsTypeExpression"),
        Core.projectionField = (Core.Name "expression")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

isTypeExpressionType :: Phantoms.TTerm Syntax.IsTypeExpression -> Phantoms.TTerm Syntax.Type
isTypeExpressionType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.IsTypeExpression"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

isTypeExpressionWithExpression :: Phantoms.TTerm Syntax.IsTypeExpression -> Phantoms.TTerm Syntax.RelationalExpression -> Phantoms.TTerm Syntax.IsTypeExpression
isTypeExpressionWithExpression original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.IsTypeExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.IsTypeExpression"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

isTypeExpressionWithType :: Phantoms.TTerm Syntax.IsTypeExpression -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.IsTypeExpression
isTypeExpressionWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.IsTypeExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.IsTypeExpression"),
              Core.projectionField = (Core.Name "expression")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

iterationStatementDo :: Phantoms.TTerm Syntax.DoStatement -> Phantoms.TTerm Syntax.IterationStatement
iterationStatementDo x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.IterationStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "do"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

iterationStatementFor :: Phantoms.TTerm Syntax.ForStatement -> Phantoms.TTerm Syntax.IterationStatement
iterationStatementFor x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.IterationStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "for"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

iterationStatementForeach :: Phantoms.TTerm Syntax.ForeachStatement -> Phantoms.TTerm Syntax.IterationStatement
iterationStatementForeach x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.IterationStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "foreach"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

iterationStatementWhile :: Phantoms.TTerm Syntax.WhileStatement -> Phantoms.TTerm Syntax.IterationStatement
iterationStatementWhile x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.IterationStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "while"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

joinClause :: Phantoms.TTerm (Maybe Syntax.Type) -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm (Maybe Syntax.Identifier) -> Phantoms.TTerm Syntax.JoinClause
joinClause type_ identifier in_ on equals into =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm identifier)},
        Core.Field {
          Core.fieldName = (Core.Name "in"),
          Core.fieldTerm = (Phantoms.unTTerm in_)},
        Core.Field {
          Core.fieldName = (Core.Name "on"),
          Core.fieldTerm = (Phantoms.unTTerm on)},
        Core.Field {
          Core.fieldName = (Core.Name "equals"),
          Core.fieldTerm = (Phantoms.unTTerm equals)},
        Core.Field {
          Core.fieldName = (Core.Name "into"),
          Core.fieldTerm = (Phantoms.unTTerm into)}]}))

joinClauseEquals :: Phantoms.TTerm Syntax.JoinClause -> Phantoms.TTerm Syntax.Expression
joinClauseEquals x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
        Core.projectionField = (Core.Name "equals")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

joinClauseIdentifier :: Phantoms.TTerm Syntax.JoinClause -> Phantoms.TTerm Syntax.Identifier
joinClauseIdentifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
        Core.projectionField = (Core.Name "identifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

joinClauseIn :: Phantoms.TTerm Syntax.JoinClause -> Phantoms.TTerm Syntax.Expression
joinClauseIn x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
        Core.projectionField = (Core.Name "in")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

joinClauseInto :: Phantoms.TTerm Syntax.JoinClause -> Phantoms.TTerm (Maybe Syntax.Identifier)
joinClauseInto x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
        Core.projectionField = (Core.Name "into")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

joinClauseOn :: Phantoms.TTerm Syntax.JoinClause -> Phantoms.TTerm Syntax.Expression
joinClauseOn x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
        Core.projectionField = (Core.Name "on")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

joinClauseType :: Phantoms.TTerm Syntax.JoinClause -> Phantoms.TTerm (Maybe Syntax.Type)
joinClauseType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

joinClauseWithEquals :: Phantoms.TTerm Syntax.JoinClause -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.JoinClause
joinClauseWithEquals original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "in"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
              Core.projectionField = (Core.Name "in")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "on"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
              Core.projectionField = (Core.Name "on")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "equals"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "into"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
              Core.projectionField = (Core.Name "into")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

joinClauseWithIdentifier :: Phantoms.TTerm Syntax.JoinClause -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.JoinClause
joinClauseWithIdentifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "in"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
              Core.projectionField = (Core.Name "in")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "on"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
              Core.projectionField = (Core.Name "on")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "equals"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
              Core.projectionField = (Core.Name "equals")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "into"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
              Core.projectionField = (Core.Name "into")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

joinClauseWithIn :: Phantoms.TTerm Syntax.JoinClause -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.JoinClause
joinClauseWithIn original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "in"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "on"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
              Core.projectionField = (Core.Name "on")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "equals"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
              Core.projectionField = (Core.Name "equals")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "into"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
              Core.projectionField = (Core.Name "into")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

joinClauseWithInto :: Phantoms.TTerm Syntax.JoinClause -> Phantoms.TTerm (Maybe Syntax.Identifier) -> Phantoms.TTerm Syntax.JoinClause
joinClauseWithInto original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "in"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
              Core.projectionField = (Core.Name "in")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "on"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
              Core.projectionField = (Core.Name "on")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "equals"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
              Core.projectionField = (Core.Name "equals")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "into"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

joinClauseWithOn :: Phantoms.TTerm Syntax.JoinClause -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.JoinClause
joinClauseWithOn original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "in"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
              Core.projectionField = (Core.Name "in")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "on"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "equals"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
              Core.projectionField = (Core.Name "equals")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "into"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
              Core.projectionField = (Core.Name "into")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

joinClauseWithType :: Phantoms.TTerm Syntax.JoinClause -> Phantoms.TTerm (Maybe Syntax.Type) -> Phantoms.TTerm Syntax.JoinClause
joinClauseWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "in"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
              Core.projectionField = (Core.Name "in")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "on"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
              Core.projectionField = (Core.Name "on")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "equals"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
              Core.projectionField = (Core.Name "equals")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "into"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.JoinClause"),
              Core.projectionField = (Core.Name "into")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

jumpStatementBreak :: Phantoms.TTerm Syntax.JumpStatement
jumpStatementBreak =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.JumpStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "break"),
        Core.fieldTerm = Core.TermUnit}}))

jumpStatementContinue :: Phantoms.TTerm Syntax.JumpStatement
jumpStatementContinue =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.JumpStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "continue"),
        Core.fieldTerm = Core.TermUnit}}))

jumpStatementGoto :: Phantoms.TTerm Syntax.GotoStatement -> Phantoms.TTerm Syntax.JumpStatement
jumpStatementGoto x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.JumpStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "goto"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

jumpStatementReturn :: Phantoms.TTerm Syntax.ReturnStatement -> Phantoms.TTerm Syntax.JumpStatement
jumpStatementReturn x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.JumpStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "return"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

jumpStatementThrow :: Phantoms.TTerm (Maybe Syntax.Expression) -> Phantoms.TTerm Syntax.JumpStatement
jumpStatementThrow x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.JumpStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "throw"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

keyword :: Phantoms.TTerm String -> Phantoms.TTerm Syntax.Keyword
keyword x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.Keyword"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

labeledStatement :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.Statement -> Phantoms.TTerm Syntax.LabeledStatement
labeledStatement label statement =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.LabeledStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "label"),
          Core.fieldTerm = (Phantoms.unTTerm label)},
        Core.Field {
          Core.fieldName = (Core.Name "statement"),
          Core.fieldTerm = (Phantoms.unTTerm statement)}]}))

labeledStatementLabel :: Phantoms.TTerm Syntax.LabeledStatement -> Phantoms.TTerm Syntax.Identifier
labeledStatementLabel x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LabeledStatement"),
        Core.projectionField = (Core.Name "label")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

labeledStatementStatement :: Phantoms.TTerm Syntax.LabeledStatement -> Phantoms.TTerm Syntax.Statement
labeledStatementStatement x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LabeledStatement"),
        Core.projectionField = (Core.Name "statement")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

labeledStatementWithLabel :: Phantoms.TTerm Syntax.LabeledStatement -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.LabeledStatement
labeledStatementWithLabel original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.LabeledStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "label"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "statement"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LabeledStatement"),
              Core.projectionField = (Core.Name "statement")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

labeledStatementWithStatement :: Phantoms.TTerm Syntax.LabeledStatement -> Phantoms.TTerm Syntax.Statement -> Phantoms.TTerm Syntax.LabeledStatement
labeledStatementWithStatement original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.LabeledStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "label"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LabeledStatement"),
              Core.projectionField = (Core.Name "label")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "statement"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

lambdaExpression :: Phantoms.TTerm Bool -> Phantoms.TTerm Syntax.AnonymousFunctionSignature -> Phantoms.TTerm Syntax.AnonymousFunctionBody -> Phantoms.TTerm Syntax.LambdaExpression
lambdaExpression async signature body =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.LambdaExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "async"),
          Core.fieldTerm = (Phantoms.unTTerm async)},
        Core.Field {
          Core.fieldName = (Core.Name "signature"),
          Core.fieldTerm = (Phantoms.unTTerm signature)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)}]}))

lambdaExpressionAsync :: Phantoms.TTerm Syntax.LambdaExpression -> Phantoms.TTerm Bool
lambdaExpressionAsync x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LambdaExpression"),
        Core.projectionField = (Core.Name "async")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

lambdaExpressionBody :: Phantoms.TTerm Syntax.LambdaExpression -> Phantoms.TTerm Syntax.AnonymousFunctionBody
lambdaExpressionBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LambdaExpression"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

lambdaExpressionSignature :: Phantoms.TTerm Syntax.LambdaExpression -> Phantoms.TTerm Syntax.AnonymousFunctionSignature
lambdaExpressionSignature x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LambdaExpression"),
        Core.projectionField = (Core.Name "signature")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

lambdaExpressionWithAsync :: Phantoms.TTerm Syntax.LambdaExpression -> Phantoms.TTerm Bool -> Phantoms.TTerm Syntax.LambdaExpression
lambdaExpressionWithAsync original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.LambdaExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "async"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "signature"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LambdaExpression"),
              Core.projectionField = (Core.Name "signature")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LambdaExpression"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

lambdaExpressionWithBody :: Phantoms.TTerm Syntax.LambdaExpression -> Phantoms.TTerm Syntax.AnonymousFunctionBody -> Phantoms.TTerm Syntax.LambdaExpression
lambdaExpressionWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.LambdaExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "async"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LambdaExpression"),
              Core.projectionField = (Core.Name "async")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "signature"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LambdaExpression"),
              Core.projectionField = (Core.Name "signature")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

lambdaExpressionWithSignature :: Phantoms.TTerm Syntax.LambdaExpression -> Phantoms.TTerm Syntax.AnonymousFunctionSignature -> Phantoms.TTerm Syntax.LambdaExpression
lambdaExpressionWithSignature original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.LambdaExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "async"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LambdaExpression"),
              Core.projectionField = (Core.Name "async")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "signature"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LambdaExpression"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

letClause :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.LetClause
letClause left right =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.LetClause"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Phantoms.unTTerm left)},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Phantoms.unTTerm right)}]}))

letClauseLeft :: Phantoms.TTerm Syntax.LetClause -> Phantoms.TTerm Syntax.Identifier
letClauseLeft x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LetClause"),
        Core.projectionField = (Core.Name "left")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

letClauseRight :: Phantoms.TTerm Syntax.LetClause -> Phantoms.TTerm Syntax.Expression
letClauseRight x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LetClause"),
        Core.projectionField = (Core.Name "right")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

letClauseWithLeft :: Phantoms.TTerm Syntax.LetClause -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.LetClause
letClauseWithLeft original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.LetClause"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LetClause"),
              Core.projectionField = (Core.Name "right")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

letClauseWithRight :: Phantoms.TTerm Syntax.LetClause -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.LetClause
letClauseWithRight original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.LetClause"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LetClause"),
              Core.projectionField = (Core.Name "left")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

literalBoolean :: Phantoms.TTerm Bool -> Phantoms.TTerm Syntax.Literal
literalBoolean x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.Literal"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "boolean"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

literalCharacter :: Phantoms.TTerm String -> Phantoms.TTerm Syntax.Literal
literalCharacter x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.Literal"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "character"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

literalInteger :: Phantoms.TTerm Syntax.IntegerLiteral -> Phantoms.TTerm Syntax.Literal
literalInteger x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.Literal"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "integer"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

literalNull :: Phantoms.TTerm Syntax.Literal
literalNull =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.Literal"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "null"),
        Core.fieldTerm = Core.TermUnit}}))

literalReal :: Phantoms.TTerm Double -> Phantoms.TTerm Syntax.Literal
literalReal x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.Literal"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "real"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

literalString :: Phantoms.TTerm String -> Phantoms.TTerm Syntax.Literal
literalString x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.Literal"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "string"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

localConstantDeclaration :: Phantoms.TTerm Syntax.Type -> Phantoms.TTerm [Syntax.ConstantDeclarator] -> Phantoms.TTerm Syntax.LocalConstantDeclaration
localConstantDeclaration type_ declarators =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.LocalConstantDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Phantoms.unTTerm declarators)}]}))

localConstantDeclarationDeclarators :: Phantoms.TTerm Syntax.LocalConstantDeclaration -> Phantoms.TTerm [Syntax.ConstantDeclarator]
localConstantDeclarationDeclarators x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LocalConstantDeclaration"),
        Core.projectionField = (Core.Name "declarators")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

localConstantDeclarationType :: Phantoms.TTerm Syntax.LocalConstantDeclaration -> Phantoms.TTerm Syntax.Type
localConstantDeclarationType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LocalConstantDeclaration"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

localConstantDeclarationWithDeclarators :: Phantoms.TTerm Syntax.LocalConstantDeclaration -> Phantoms.TTerm [Syntax.ConstantDeclarator] -> Phantoms.TTerm Syntax.LocalConstantDeclaration
localConstantDeclarationWithDeclarators original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.LocalConstantDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LocalConstantDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

localConstantDeclarationWithType :: Phantoms.TTerm Syntax.LocalConstantDeclaration -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.LocalConstantDeclaration
localConstantDeclarationWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.LocalConstantDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LocalConstantDeclaration"),
              Core.projectionField = (Core.Name "declarators")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

localFunctionBodyBlock :: Phantoms.TTerm Syntax.Block -> Phantoms.TTerm Syntax.LocalFunctionBody
localFunctionBodyBlock x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.LocalFunctionBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "block"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

localFunctionBodyExpression :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.LocalFunctionBody
localFunctionBodyExpression x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.LocalFunctionBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "expression"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

localFunctionBodyNullConditionalInvocation :: Phantoms.TTerm Syntax.NullConditionalInvocationExpression -> Phantoms.TTerm Syntax.LocalFunctionBody
localFunctionBodyNullConditionalInvocation x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.LocalFunctionBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "nullConditionalInvocation"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

localFunctionDeclarationRef :: Phantoms.TTerm Syntax.RefLocalFunctionDeclaration -> Phantoms.TTerm Syntax.LocalFunctionDeclaration
localFunctionDeclarationRef x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.LocalFunctionDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "ref"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

localFunctionDeclarationStandard :: Phantoms.TTerm Syntax.StandardLocalFunctionDeclaration -> Phantoms.TTerm Syntax.LocalFunctionDeclaration
localFunctionDeclarationStandard x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.LocalFunctionDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "standard"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

localFunctionHeader :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm (Maybe Syntax.TypeParameterList) -> Phantoms.TTerm Syntax.FormalParameterList -> Phantoms.TTerm [Syntax.TypeParameterConstraintsClause] -> Phantoms.TTerm Syntax.LocalFunctionHeader
localFunctionHeader identifier typeParameters parameters constraints =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.LocalFunctionHeader"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm identifier)},
        Core.Field {
          Core.fieldName = (Core.Name "typeParameters"),
          Core.fieldTerm = (Phantoms.unTTerm typeParameters)},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Phantoms.unTTerm parameters)},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Phantoms.unTTerm constraints)}]}))

localFunctionHeaderConstraints :: Phantoms.TTerm Syntax.LocalFunctionHeader -> Phantoms.TTerm [Syntax.TypeParameterConstraintsClause]
localFunctionHeaderConstraints x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LocalFunctionHeader"),
        Core.projectionField = (Core.Name "constraints")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

localFunctionHeaderIdentifier :: Phantoms.TTerm Syntax.LocalFunctionHeader -> Phantoms.TTerm Syntax.Identifier
localFunctionHeaderIdentifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LocalFunctionHeader"),
        Core.projectionField = (Core.Name "identifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

localFunctionHeaderParameters :: Phantoms.TTerm Syntax.LocalFunctionHeader -> Phantoms.TTerm Syntax.FormalParameterList
localFunctionHeaderParameters x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LocalFunctionHeader"),
        Core.projectionField = (Core.Name "parameters")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

localFunctionHeaderTypeParameters :: Phantoms.TTerm Syntax.LocalFunctionHeader -> Phantoms.TTerm (Maybe Syntax.TypeParameterList)
localFunctionHeaderTypeParameters x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LocalFunctionHeader"),
        Core.projectionField = (Core.Name "typeParameters")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

localFunctionHeaderWithConstraints :: Phantoms.TTerm Syntax.LocalFunctionHeader -> Phantoms.TTerm [Syntax.TypeParameterConstraintsClause] -> Phantoms.TTerm Syntax.LocalFunctionHeader
localFunctionHeaderWithConstraints original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.LocalFunctionHeader"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LocalFunctionHeader"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "typeParameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LocalFunctionHeader"),
              Core.projectionField = (Core.Name "typeParameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LocalFunctionHeader"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

localFunctionHeaderWithIdentifier :: Phantoms.TTerm Syntax.LocalFunctionHeader -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.LocalFunctionHeader
localFunctionHeaderWithIdentifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.LocalFunctionHeader"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "typeParameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LocalFunctionHeader"),
              Core.projectionField = (Core.Name "typeParameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LocalFunctionHeader"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LocalFunctionHeader"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

localFunctionHeaderWithParameters :: Phantoms.TTerm Syntax.LocalFunctionHeader -> Phantoms.TTerm Syntax.FormalParameterList -> Phantoms.TTerm Syntax.LocalFunctionHeader
localFunctionHeaderWithParameters original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.LocalFunctionHeader"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LocalFunctionHeader"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "typeParameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LocalFunctionHeader"),
              Core.projectionField = (Core.Name "typeParameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LocalFunctionHeader"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

localFunctionHeaderWithTypeParameters :: Phantoms.TTerm Syntax.LocalFunctionHeader -> Phantoms.TTerm (Maybe Syntax.TypeParameterList) -> Phantoms.TTerm Syntax.LocalFunctionHeader
localFunctionHeaderWithTypeParameters original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.LocalFunctionHeader"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LocalFunctionHeader"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "typeParameters"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LocalFunctionHeader"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LocalFunctionHeader"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

localFunctionModifierAsync :: Phantoms.TTerm Syntax.LocalFunctionModifier
localFunctionModifierAsync =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.LocalFunctionModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "async"),
        Core.fieldTerm = Core.TermUnit}}))

localFunctionModifierRef :: Phantoms.TTerm Syntax.RefLocalFunctionModifier -> Phantoms.TTerm Syntax.LocalFunctionModifier
localFunctionModifierRef x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.LocalFunctionModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "ref"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

localVariableDeclarationExplicitlyTyped :: Phantoms.TTerm Syntax.ExplicitlyTypedLocalVariableDeclaration -> Phantoms.TTerm Syntax.LocalVariableDeclaration
localVariableDeclarationExplicitlyTyped x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.LocalVariableDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "explicitlyTyped"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

localVariableDeclarationImplicitlyTyped :: Phantoms.TTerm Syntax.ImplicitlyTypedLocalVariableDeclaration -> Phantoms.TTerm Syntax.LocalVariableDeclaration
localVariableDeclarationImplicitlyTyped x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.LocalVariableDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "implicitlyTyped"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

localVariableDeclarationRef :: Phantoms.TTerm Syntax.RefLocalVariableDeclaration -> Phantoms.TTerm Syntax.LocalVariableDeclaration
localVariableDeclarationRef x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.LocalVariableDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "ref"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

localVariableInitializerExpression :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.LocalVariableInitializer
localVariableInitializerExpression x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.LocalVariableInitializer"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "expression"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

localVariableInitializerInitializer :: Phantoms.TTerm Syntax.ArrayInitializer -> Phantoms.TTerm Syntax.LocalVariableInitializer
localVariableInitializerInitializer x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.LocalVariableInitializer"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "initializer"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

localVariableTypeType :: Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.LocalVariableType
localVariableTypeType x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.LocalVariableType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "type"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

localVariableTypeVar :: Phantoms.TTerm Syntax.LocalVariableType
localVariableTypeVar =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.LocalVariableType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "var"),
        Core.fieldTerm = Core.TermUnit}}))

lockStatement :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.EmbeddedStatement -> Phantoms.TTerm Syntax.LockStatement
lockStatement expression body =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.LockStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm expression)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)}]}))

lockStatementBody :: Phantoms.TTerm Syntax.LockStatement -> Phantoms.TTerm Syntax.EmbeddedStatement
lockStatementBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LockStatement"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

lockStatementExpression :: Phantoms.TTerm Syntax.LockStatement -> Phantoms.TTerm Syntax.Expression
lockStatementExpression x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LockStatement"),
        Core.projectionField = (Core.Name "expression")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

lockStatementWithBody :: Phantoms.TTerm Syntax.LockStatement -> Phantoms.TTerm Syntax.EmbeddedStatement -> Phantoms.TTerm Syntax.LockStatement
lockStatementWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.LockStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LockStatement"),
              Core.projectionField = (Core.Name "expression")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

lockStatementWithExpression :: Phantoms.TTerm Syntax.LockStatement -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.LockStatement
lockStatementWithExpression original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.LockStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.LockStatement"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

memberAccess :: Phantoms.TTerm Syntax.MemberAccessHead -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList) -> Phantoms.TTerm Syntax.MemberAccess
memberAccess head identifier typeArguments =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.MemberAccess"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "head"),
          Core.fieldTerm = (Phantoms.unTTerm head)},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm identifier)},
        Core.Field {
          Core.fieldName = (Core.Name "typeArguments"),
          Core.fieldTerm = (Phantoms.unTTerm typeArguments)}]}))

memberAccessHead :: Phantoms.TTerm Syntax.MemberAccess -> Phantoms.TTerm Syntax.MemberAccessHead
memberAccessHead x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MemberAccess"),
        Core.projectionField = (Core.Name "head")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

memberAccessHeadPredefined :: Phantoms.TTerm Syntax.PredefinedType -> Phantoms.TTerm Syntax.MemberAccessHead
memberAccessHeadPredefined x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.MemberAccessHead"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "predefined"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

memberAccessHeadPrimary :: Phantoms.TTerm Syntax.PrimaryExpression -> Phantoms.TTerm Syntax.MemberAccessHead
memberAccessHeadPrimary x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.MemberAccessHead"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "primary"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

memberAccessHeadQualifiedAlias :: Phantoms.TTerm Syntax.QualifiedAliasMember -> Phantoms.TTerm Syntax.MemberAccessHead
memberAccessHeadQualifiedAlias x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.MemberAccessHead"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "qualifiedAlias"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

memberAccessIdentifier :: Phantoms.TTerm Syntax.MemberAccess -> Phantoms.TTerm Syntax.Identifier
memberAccessIdentifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MemberAccess"),
        Core.projectionField = (Core.Name "identifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

memberAccessTypeArguments :: Phantoms.TTerm Syntax.MemberAccess -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList)
memberAccessTypeArguments x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MemberAccess"),
        Core.projectionField = (Core.Name "typeArguments")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

memberAccessWithHead :: Phantoms.TTerm Syntax.MemberAccess -> Phantoms.TTerm Syntax.MemberAccessHead -> Phantoms.TTerm Syntax.MemberAccess
memberAccessWithHead original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.MemberAccess"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "head"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MemberAccess"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "typeArguments"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MemberAccess"),
              Core.projectionField = (Core.Name "typeArguments")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

memberAccessWithIdentifier :: Phantoms.TTerm Syntax.MemberAccess -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.MemberAccess
memberAccessWithIdentifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.MemberAccess"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "head"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MemberAccess"),
              Core.projectionField = (Core.Name "head")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "typeArguments"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MemberAccess"),
              Core.projectionField = (Core.Name "typeArguments")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

memberAccessWithTypeArguments :: Phantoms.TTerm Syntax.MemberAccess -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList) -> Phantoms.TTerm Syntax.MemberAccess
memberAccessWithTypeArguments original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.MemberAccess"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "head"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MemberAccess"),
              Core.projectionField = (Core.Name "head")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MemberAccess"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "typeArguments"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

memberDeclaratorAssignment :: Phantoms.TTerm Syntax.AssignmentMemberDeclarator -> Phantoms.TTerm Syntax.MemberDeclarator
memberDeclaratorAssignment x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.MemberDeclarator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "assignment"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

memberDeclaratorBaseAccess :: Phantoms.TTerm Syntax.BaseAccess -> Phantoms.TTerm Syntax.MemberDeclarator
memberDeclaratorBaseAccess x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.MemberDeclarator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "baseAccess"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

memberDeclaratorList :: Phantoms.TTerm [Syntax.MemberDeclarator] -> Phantoms.TTerm Syntax.MemberDeclaratorList
memberDeclaratorList x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.MemberDeclaratorList"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

memberDeclaratorMemberAccess :: Phantoms.TTerm Syntax.MemberAccess -> Phantoms.TTerm Syntax.MemberDeclarator
memberDeclaratorMemberAccess x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.MemberDeclarator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "memberAccess"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

memberDeclaratorName :: Phantoms.TTerm Syntax.SimpleName -> Phantoms.TTerm Syntax.MemberDeclarator
memberDeclaratorName x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.MemberDeclarator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "name"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

memberDeclaratorNullConditionalProjectionInitializer :: Phantoms.TTerm Syntax.NullConditionalProjectionInitializer -> Phantoms.TTerm Syntax.MemberDeclarator
memberDeclaratorNullConditionalProjectionInitializer x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.MemberDeclarator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "nullConditionalProjectionInitializer"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

memberInitializer :: Phantoms.TTerm Syntax.InitializerTarget -> Phantoms.TTerm Syntax.InitializerValue -> Phantoms.TTerm Syntax.MemberInitializer
memberInitializer target value =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.MemberInitializer"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "target"),
          Core.fieldTerm = (Phantoms.unTTerm target)},
        Core.Field {
          Core.fieldName = (Core.Name "value"),
          Core.fieldTerm = (Phantoms.unTTerm value)}]}))

memberInitializerTarget :: Phantoms.TTerm Syntax.MemberInitializer -> Phantoms.TTerm Syntax.InitializerTarget
memberInitializerTarget x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MemberInitializer"),
        Core.projectionField = (Core.Name "target")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

memberInitializerValue :: Phantoms.TTerm Syntax.MemberInitializer -> Phantoms.TTerm Syntax.InitializerValue
memberInitializerValue x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MemberInitializer"),
        Core.projectionField = (Core.Name "value")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

memberInitializerWithTarget :: Phantoms.TTerm Syntax.MemberInitializer -> Phantoms.TTerm Syntax.InitializerTarget -> Phantoms.TTerm Syntax.MemberInitializer
memberInitializerWithTarget original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.MemberInitializer"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "target"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "value"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MemberInitializer"),
              Core.projectionField = (Core.Name "value")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

memberInitializerWithValue :: Phantoms.TTerm Syntax.MemberInitializer -> Phantoms.TTerm Syntax.InitializerValue -> Phantoms.TTerm Syntax.MemberInitializer
memberInitializerWithValue original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.MemberInitializer"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "target"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MemberInitializer"),
              Core.projectionField = (Core.Name "target")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "value"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

memberName :: Phantoms.TTerm (Maybe Syntax.TypeName) -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.MemberName
memberName interfaceType identifier =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.MemberName"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "interfaceType"),
          Core.fieldTerm = (Phantoms.unTTerm interfaceType)},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm identifier)}]}))

memberNameIdentifier :: Phantoms.TTerm Syntax.MemberName -> Phantoms.TTerm Syntax.Identifier
memberNameIdentifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MemberName"),
        Core.projectionField = (Core.Name "identifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

memberNameInterfaceType :: Phantoms.TTerm Syntax.MemberName -> Phantoms.TTerm (Maybe Syntax.TypeName)
memberNameInterfaceType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MemberName"),
        Core.projectionField = (Core.Name "interfaceType")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

memberNameWithIdentifier :: Phantoms.TTerm Syntax.MemberName -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.MemberName
memberNameWithIdentifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.MemberName"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "interfaceType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MemberName"),
              Core.projectionField = (Core.Name "interfaceType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

memberNameWithInterfaceType :: Phantoms.TTerm Syntax.MemberName -> Phantoms.TTerm (Maybe Syntax.TypeName) -> Phantoms.TTerm Syntax.MemberName
memberNameWithInterfaceType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.MemberName"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "interfaceType"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MemberName"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

methodBodyBlock :: Phantoms.TTerm Syntax.Block -> Phantoms.TTerm Syntax.MethodBody
methodBodyBlock x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.MethodBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "block"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

methodBodyEmpty :: Phantoms.TTerm Syntax.MethodBody
methodBodyEmpty =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.MethodBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "empty"),
        Core.fieldTerm = Core.TermUnit}}))

methodBodyExpression :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.MethodBody
methodBodyExpression x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.MethodBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "expression"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

methodBodyNullConditionalInvocation :: Phantoms.TTerm Syntax.NullConditionalInvocationExpression -> Phantoms.TTerm Syntax.MethodBody
methodBodyNullConditionalInvocation x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.MethodBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "nullConditionalInvocation"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

methodDeclarationRefReturn :: Phantoms.TTerm Syntax.RefReturnMethodDeclaration -> Phantoms.TTerm Syntax.MethodDeclaration
methodDeclarationRefReturn x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.MethodDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "refReturn"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

methodDeclarationStandard :: Phantoms.TTerm Syntax.StandardMethodDeclaration -> Phantoms.TTerm Syntax.MethodDeclaration
methodDeclarationStandard x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.MethodDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "standard"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

methodHeader :: Phantoms.TTerm Syntax.MemberName -> Phantoms.TTerm (Maybe Syntax.TypeParameterList) -> Phantoms.TTerm (Maybe Syntax.FormalParameterList) -> Phantoms.TTerm [Syntax.TypeParameterConstraintsClause] -> Phantoms.TTerm Syntax.MethodHeader
methodHeader name typeParameters parameters constraints =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.MethodHeader"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm name)},
        Core.Field {
          Core.fieldName = (Core.Name "typeParameters"),
          Core.fieldTerm = (Phantoms.unTTerm typeParameters)},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Phantoms.unTTerm parameters)},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Phantoms.unTTerm constraints)}]}))

methodHeaderConstraints :: Phantoms.TTerm Syntax.MethodHeader -> Phantoms.TTerm [Syntax.TypeParameterConstraintsClause]
methodHeaderConstraints x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MethodHeader"),
        Core.projectionField = (Core.Name "constraints")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

methodHeaderName :: Phantoms.TTerm Syntax.MethodHeader -> Phantoms.TTerm Syntax.MemberName
methodHeaderName x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MethodHeader"),
        Core.projectionField = (Core.Name "name")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

methodHeaderParameters :: Phantoms.TTerm Syntax.MethodHeader -> Phantoms.TTerm (Maybe Syntax.FormalParameterList)
methodHeaderParameters x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MethodHeader"),
        Core.projectionField = (Core.Name "parameters")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

methodHeaderTypeParameters :: Phantoms.TTerm Syntax.MethodHeader -> Phantoms.TTerm (Maybe Syntax.TypeParameterList)
methodHeaderTypeParameters x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MethodHeader"),
        Core.projectionField = (Core.Name "typeParameters")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

methodHeaderWithConstraints :: Phantoms.TTerm Syntax.MethodHeader -> Phantoms.TTerm [Syntax.TypeParameterConstraintsClause] -> Phantoms.TTerm Syntax.MethodHeader
methodHeaderWithConstraints original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.MethodHeader"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MethodHeader"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "typeParameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MethodHeader"),
              Core.projectionField = (Core.Name "typeParameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MethodHeader"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

methodHeaderWithName :: Phantoms.TTerm Syntax.MethodHeader -> Phantoms.TTerm Syntax.MemberName -> Phantoms.TTerm Syntax.MethodHeader
methodHeaderWithName original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.MethodHeader"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "typeParameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MethodHeader"),
              Core.projectionField = (Core.Name "typeParameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MethodHeader"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MethodHeader"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

methodHeaderWithParameters :: Phantoms.TTerm Syntax.MethodHeader -> Phantoms.TTerm (Maybe Syntax.FormalParameterList) -> Phantoms.TTerm Syntax.MethodHeader
methodHeaderWithParameters original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.MethodHeader"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MethodHeader"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "typeParameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MethodHeader"),
              Core.projectionField = (Core.Name "typeParameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MethodHeader"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

methodHeaderWithTypeParameters :: Phantoms.TTerm Syntax.MethodHeader -> Phantoms.TTerm (Maybe Syntax.TypeParameterList) -> Phantoms.TTerm Syntax.MethodHeader
methodHeaderWithTypeParameters original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.MethodHeader"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MethodHeader"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "typeParameters"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MethodHeader"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MethodHeader"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

methodModifierAsync :: Phantoms.TTerm Syntax.MethodModifier
methodModifierAsync =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.MethodModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "async"),
        Core.fieldTerm = Core.TermUnit}}))

methodModifierRef :: Phantoms.TTerm Syntax.RefMethodModifier -> Phantoms.TTerm Syntax.MethodModifier
methodModifierRef x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.MethodModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "ref"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

methodModifiers :: Phantoms.TTerm [Syntax.MethodModifier] -> Phantoms.TTerm Bool -> Phantoms.TTerm Syntax.MethodModifiers
methodModifiers modifiers partial =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.MethodModifiers"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm modifiers)},
        Core.Field {
          Core.fieldName = (Core.Name "partial"),
          Core.fieldTerm = (Phantoms.unTTerm partial)}]}))

methodModifiersModifiers :: Phantoms.TTerm Syntax.MethodModifiers -> Phantoms.TTerm [Syntax.MethodModifier]
methodModifiersModifiers x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MethodModifiers"),
        Core.projectionField = (Core.Name "modifiers")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

methodModifiersPartial :: Phantoms.TTerm Syntax.MethodModifiers -> Phantoms.TTerm Bool
methodModifiersPartial x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MethodModifiers"),
        Core.projectionField = (Core.Name "partial")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

methodModifiersWithModifiers :: Phantoms.TTerm Syntax.MethodModifiers -> Phantoms.TTerm [Syntax.MethodModifier] -> Phantoms.TTerm Syntax.MethodModifiers
methodModifiersWithModifiers original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.MethodModifiers"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "partial"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MethodModifiers"),
              Core.projectionField = (Core.Name "partial")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

methodModifiersWithPartial :: Phantoms.TTerm Syntax.MethodModifiers -> Phantoms.TTerm Bool -> Phantoms.TTerm Syntax.MethodModifiers
methodModifiersWithPartial original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.MethodModifiers"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.MethodModifiers"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "partial"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

multiplicativeExpressionBinary :: Phantoms.TTerm Syntax.BinaryMultiplicativeExpression -> Phantoms.TTerm Syntax.MultiplicativeExpression
multiplicativeExpressionBinary x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.MultiplicativeExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "binary"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

multiplicativeExpressionSimple :: Phantoms.TTerm Syntax.UnaryExpression -> Phantoms.TTerm Syntax.MultiplicativeExpression
multiplicativeExpressionSimple x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.MultiplicativeExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "simple"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

multiplicativeOperatorDivide :: Phantoms.TTerm Syntax.MultiplicativeOperator
multiplicativeOperatorDivide =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.MultiplicativeOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "divide"),
        Core.fieldTerm = Core.TermUnit}}))

multiplicativeOperatorModulo :: Phantoms.TTerm Syntax.MultiplicativeOperator
multiplicativeOperatorModulo =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.MultiplicativeOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "modulo"),
        Core.fieldTerm = Core.TermUnit}}))

multiplicativeOperatorTimes :: Phantoms.TTerm Syntax.MultiplicativeOperator
multiplicativeOperatorTimes =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.MultiplicativeOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "times"),
        Core.fieldTerm = Core.TermUnit}}))

namedArgument :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.AttributeArgumentExpression -> Phantoms.TTerm Syntax.NamedArgument
namedArgument name value =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NamedArgument"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm name)},
        Core.Field {
          Core.fieldName = (Core.Name "value"),
          Core.fieldTerm = (Phantoms.unTTerm value)}]}))

namedArgumentList :: Phantoms.TTerm [Syntax.NamedArgument] -> Phantoms.TTerm Syntax.NamedArgumentList
namedArgumentList x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.NamedArgumentList"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

namedArgumentName :: Phantoms.TTerm Syntax.NamedArgument -> Phantoms.TTerm Syntax.Identifier
namedArgumentName x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NamedArgument"),
        Core.projectionField = (Core.Name "name")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

namedArgumentValue :: Phantoms.TTerm Syntax.NamedArgument -> Phantoms.TTerm Syntax.AttributeArgumentExpression
namedArgumentValue x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NamedArgument"),
        Core.projectionField = (Core.Name "value")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

namedArgumentWithName :: Phantoms.TTerm Syntax.NamedArgument -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.NamedArgument
namedArgumentWithName original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NamedArgument"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "value"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NamedArgument"),
              Core.projectionField = (Core.Name "value")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

namedArgumentWithValue :: Phantoms.TTerm Syntax.NamedArgument -> Phantoms.TTerm Syntax.AttributeArgumentExpression -> Phantoms.TTerm Syntax.NamedArgument
namedArgumentWithValue original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NamedArgument"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NamedArgument"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "value"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

namedEntity :: Phantoms.TTerm Syntax.NamedEntityTarget -> Phantoms.TTerm [Syntax.NamedEntityPart] -> Phantoms.TTerm Syntax.NamedEntity
namedEntity target parts =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NamedEntity"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "target"),
          Core.fieldTerm = (Phantoms.unTTerm target)},
        Core.Field {
          Core.fieldName = (Core.Name "parts"),
          Core.fieldTerm = (Phantoms.unTTerm parts)}]}))

namedEntityPart :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList) -> Phantoms.TTerm Syntax.NamedEntityPart
namedEntityPart identifier typeArguments =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NamedEntityPart"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm identifier)},
        Core.Field {
          Core.fieldName = (Core.Name "typeArguments"),
          Core.fieldTerm = (Phantoms.unTTerm typeArguments)}]}))

namedEntityPartIdentifier :: Phantoms.TTerm Syntax.NamedEntityPart -> Phantoms.TTerm Syntax.Identifier
namedEntityPartIdentifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NamedEntityPart"),
        Core.projectionField = (Core.Name "identifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

namedEntityPartTypeArguments :: Phantoms.TTerm Syntax.NamedEntityPart -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList)
namedEntityPartTypeArguments x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NamedEntityPart"),
        Core.projectionField = (Core.Name "typeArguments")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

namedEntityPartWithIdentifier :: Phantoms.TTerm Syntax.NamedEntityPart -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.NamedEntityPart
namedEntityPartWithIdentifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NamedEntityPart"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "typeArguments"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NamedEntityPart"),
              Core.projectionField = (Core.Name "typeArguments")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

namedEntityPartWithTypeArguments :: Phantoms.TTerm Syntax.NamedEntityPart -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList) -> Phantoms.TTerm Syntax.NamedEntityPart
namedEntityPartWithTypeArguments original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NamedEntityPart"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NamedEntityPart"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "typeArguments"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

namedEntityParts :: Phantoms.TTerm Syntax.NamedEntity -> Phantoms.TTerm [Syntax.NamedEntityPart]
namedEntityParts x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NamedEntity"),
        Core.projectionField = (Core.Name "parts")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

namedEntityTarget :: Phantoms.TTerm Syntax.NamedEntity -> Phantoms.TTerm Syntax.NamedEntityTarget
namedEntityTarget x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NamedEntity"),
        Core.projectionField = (Core.Name "target")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

namedEntityTargetBase :: Phantoms.TTerm Syntax.NamedEntityTarget
namedEntityTargetBase =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.NamedEntityTarget"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "base"),
        Core.fieldTerm = Core.TermUnit}}))

namedEntityTargetName :: Phantoms.TTerm Syntax.SimpleName -> Phantoms.TTerm Syntax.NamedEntityTarget
namedEntityTargetName x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.NamedEntityTarget"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "name"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

namedEntityTargetPredefinedType :: Phantoms.TTerm Syntax.PredefinedType -> Phantoms.TTerm Syntax.NamedEntityTarget
namedEntityTargetPredefinedType x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.NamedEntityTarget"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "predefinedType"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

namedEntityTargetQualifiedAliasMember :: Phantoms.TTerm Syntax.QualifiedAliasMember -> Phantoms.TTerm Syntax.NamedEntityTarget
namedEntityTargetQualifiedAliasMember x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.NamedEntityTarget"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "qualifiedAliasMember"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

namedEntityTargetThis :: Phantoms.TTerm Syntax.NamedEntityTarget
namedEntityTargetThis =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.NamedEntityTarget"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "this"),
        Core.fieldTerm = Core.TermUnit}}))

namedEntityWithParts :: Phantoms.TTerm Syntax.NamedEntity -> Phantoms.TTerm [Syntax.NamedEntityPart] -> Phantoms.TTerm Syntax.NamedEntity
namedEntityWithParts original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NamedEntity"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "target"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NamedEntity"),
              Core.projectionField = (Core.Name "target")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parts"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

namedEntityWithTarget :: Phantoms.TTerm Syntax.NamedEntity -> Phantoms.TTerm Syntax.NamedEntityTarget -> Phantoms.TTerm Syntax.NamedEntity
namedEntityWithTarget original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NamedEntity"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "target"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "parts"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NamedEntity"),
              Core.projectionField = (Core.Name "parts")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

namespaceBody :: Phantoms.TTerm [Syntax.ExternAliasDirective] -> Phantoms.TTerm [Syntax.UsingDirective] -> Phantoms.TTerm [Syntax.NamespaceMemberDeclaration] -> Phantoms.TTerm Syntax.NamespaceBody
namespaceBody externs usings members =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NamespaceBody"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "externs"),
          Core.fieldTerm = (Phantoms.unTTerm externs)},
        Core.Field {
          Core.fieldName = (Core.Name "usings"),
          Core.fieldTerm = (Phantoms.unTTerm usings)},
        Core.Field {
          Core.fieldName = (Core.Name "members"),
          Core.fieldTerm = (Phantoms.unTTerm members)}]}))

namespaceBodyExterns :: Phantoms.TTerm Syntax.NamespaceBody -> Phantoms.TTerm [Syntax.ExternAliasDirective]
namespaceBodyExterns x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NamespaceBody"),
        Core.projectionField = (Core.Name "externs")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

namespaceBodyMembers :: Phantoms.TTerm Syntax.NamespaceBody -> Phantoms.TTerm [Syntax.NamespaceMemberDeclaration]
namespaceBodyMembers x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NamespaceBody"),
        Core.projectionField = (Core.Name "members")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

namespaceBodyUsings :: Phantoms.TTerm Syntax.NamespaceBody -> Phantoms.TTerm [Syntax.UsingDirective]
namespaceBodyUsings x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NamespaceBody"),
        Core.projectionField = (Core.Name "usings")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

namespaceBodyWithExterns :: Phantoms.TTerm Syntax.NamespaceBody -> Phantoms.TTerm [Syntax.ExternAliasDirective] -> Phantoms.TTerm Syntax.NamespaceBody
namespaceBodyWithExterns original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NamespaceBody"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "externs"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "usings"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NamespaceBody"),
              Core.projectionField = (Core.Name "usings")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "members"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NamespaceBody"),
              Core.projectionField = (Core.Name "members")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

namespaceBodyWithMembers :: Phantoms.TTerm Syntax.NamespaceBody -> Phantoms.TTerm [Syntax.NamespaceMemberDeclaration] -> Phantoms.TTerm Syntax.NamespaceBody
namespaceBodyWithMembers original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NamespaceBody"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "externs"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NamespaceBody"),
              Core.projectionField = (Core.Name "externs")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "usings"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NamespaceBody"),
              Core.projectionField = (Core.Name "usings")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "members"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

namespaceBodyWithUsings :: Phantoms.TTerm Syntax.NamespaceBody -> Phantoms.TTerm [Syntax.UsingDirective] -> Phantoms.TTerm Syntax.NamespaceBody
namespaceBodyWithUsings original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NamespaceBody"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "externs"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NamespaceBody"),
              Core.projectionField = (Core.Name "externs")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "usings"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "members"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NamespaceBody"),
              Core.projectionField = (Core.Name "members")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

namespaceDeclaration :: Phantoms.TTerm Syntax.QualifiedIdentifier -> Phantoms.TTerm Syntax.NamespaceBody -> Phantoms.TTerm Syntax.NamespaceDeclaration
namespaceDeclaration name body =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NamespaceDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm name)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)}]}))

namespaceDeclarationBody :: Phantoms.TTerm Syntax.NamespaceDeclaration -> Phantoms.TTerm Syntax.NamespaceBody
namespaceDeclarationBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NamespaceDeclaration"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

namespaceDeclarationName :: Phantoms.TTerm Syntax.NamespaceDeclaration -> Phantoms.TTerm Syntax.QualifiedIdentifier
namespaceDeclarationName x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NamespaceDeclaration"),
        Core.projectionField = (Core.Name "name")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

namespaceDeclarationWithBody :: Phantoms.TTerm Syntax.NamespaceDeclaration -> Phantoms.TTerm Syntax.NamespaceBody -> Phantoms.TTerm Syntax.NamespaceDeclaration
namespaceDeclarationWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NamespaceDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NamespaceDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

namespaceDeclarationWithName :: Phantoms.TTerm Syntax.NamespaceDeclaration -> Phantoms.TTerm Syntax.QualifiedIdentifier -> Phantoms.TTerm Syntax.NamespaceDeclaration
namespaceDeclarationWithName original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NamespaceDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NamespaceDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

namespaceMemberDeclarationNamespace :: Phantoms.TTerm Syntax.NamespaceDeclaration -> Phantoms.TTerm Syntax.NamespaceMemberDeclaration
namespaceMemberDeclarationNamespace x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.NamespaceMemberDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "namespace"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

namespaceMemberDeclarationType :: Phantoms.TTerm Syntax.TypeDeclaration -> Phantoms.TTerm Syntax.NamespaceMemberDeclaration
namespaceMemberDeclarationType x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.NamespaceMemberDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "type"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

namespaceName :: Phantoms.TTerm Syntax.NamespaceOrTypeName -> Phantoms.TTerm Syntax.NamespaceName
namespaceName x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.NamespaceName"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

namespaceOrTypeNameAlias :: Phantoms.TTerm Syntax.QualifiedAliasMember -> Phantoms.TTerm Syntax.NamespaceOrTypeName
namespaceOrTypeNameAlias x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.NamespaceOrTypeName"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "alias"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

namespaceOrTypeNameIdentifier :: Phantoms.TTerm Syntax.IdentifierNamespaceOrTypeName -> Phantoms.TTerm Syntax.NamespaceOrTypeName
namespaceOrTypeNameIdentifier x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.NamespaceOrTypeName"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "identifier"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

namespaceOrTypeNameQualified :: Phantoms.TTerm Syntax.QualifiedNamespaceOrTypeName -> Phantoms.TTerm Syntax.NamespaceOrTypeName
namespaceOrTypeNameQualified x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.NamespaceOrTypeName"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "qualified"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

nonArrayTypeArrayCreationExpression :: Phantoms.TTerm Syntax.NonArrayType -> Phantoms.TTerm Syntax.ExpressionList -> Phantoms.TTerm [Syntax.RankSpecifier] -> Phantoms.TTerm (Maybe Syntax.ArrayInitializer) -> Phantoms.TTerm Syntax.NonArrayTypeArrayCreationExpression
nonArrayTypeArrayCreationExpression type_ expressions rankSpecifiers initializer =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NonArrayTypeArrayCreationExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "expressions"),
          Core.fieldTerm = (Phantoms.unTTerm expressions)},
        Core.Field {
          Core.fieldName = (Core.Name "rankSpecifiers"),
          Core.fieldTerm = (Phantoms.unTTerm rankSpecifiers)},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Phantoms.unTTerm initializer)}]}))

nonArrayTypeArrayCreationExpressionExpressions :: Phantoms.TTerm Syntax.NonArrayTypeArrayCreationExpression -> Phantoms.TTerm Syntax.ExpressionList
nonArrayTypeArrayCreationExpressionExpressions x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NonArrayTypeArrayCreationExpression"),
        Core.projectionField = (Core.Name "expressions")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

nonArrayTypeArrayCreationExpressionInitializer :: Phantoms.TTerm Syntax.NonArrayTypeArrayCreationExpression -> Phantoms.TTerm (Maybe Syntax.ArrayInitializer)
nonArrayTypeArrayCreationExpressionInitializer x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NonArrayTypeArrayCreationExpression"),
        Core.projectionField = (Core.Name "initializer")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

nonArrayTypeArrayCreationExpressionRankSpecifiers :: Phantoms.TTerm Syntax.NonArrayTypeArrayCreationExpression -> Phantoms.TTerm [Syntax.RankSpecifier]
nonArrayTypeArrayCreationExpressionRankSpecifiers x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NonArrayTypeArrayCreationExpression"),
        Core.projectionField = (Core.Name "rankSpecifiers")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

nonArrayTypeArrayCreationExpressionType :: Phantoms.TTerm Syntax.NonArrayTypeArrayCreationExpression -> Phantoms.TTerm Syntax.NonArrayType
nonArrayTypeArrayCreationExpressionType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NonArrayTypeArrayCreationExpression"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

nonArrayTypeArrayCreationExpressionWithExpressions :: Phantoms.TTerm Syntax.NonArrayTypeArrayCreationExpression -> Phantoms.TTerm Syntax.ExpressionList -> Phantoms.TTerm Syntax.NonArrayTypeArrayCreationExpression
nonArrayTypeArrayCreationExpressionWithExpressions original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NonArrayTypeArrayCreationExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NonArrayTypeArrayCreationExpression"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "expressions"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "rankSpecifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NonArrayTypeArrayCreationExpression"),
              Core.projectionField = (Core.Name "rankSpecifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NonArrayTypeArrayCreationExpression"),
              Core.projectionField = (Core.Name "initializer")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

nonArrayTypeArrayCreationExpressionWithInitializer :: Phantoms.TTerm Syntax.NonArrayTypeArrayCreationExpression -> Phantoms.TTerm (Maybe Syntax.ArrayInitializer) -> Phantoms.TTerm Syntax.NonArrayTypeArrayCreationExpression
nonArrayTypeArrayCreationExpressionWithInitializer original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NonArrayTypeArrayCreationExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NonArrayTypeArrayCreationExpression"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "expressions"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NonArrayTypeArrayCreationExpression"),
              Core.projectionField = (Core.Name "expressions")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "rankSpecifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NonArrayTypeArrayCreationExpression"),
              Core.projectionField = (Core.Name "rankSpecifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

nonArrayTypeArrayCreationExpressionWithRankSpecifiers :: Phantoms.TTerm Syntax.NonArrayTypeArrayCreationExpression -> Phantoms.TTerm [Syntax.RankSpecifier] -> Phantoms.TTerm Syntax.NonArrayTypeArrayCreationExpression
nonArrayTypeArrayCreationExpressionWithRankSpecifiers original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NonArrayTypeArrayCreationExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NonArrayTypeArrayCreationExpression"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "expressions"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NonArrayTypeArrayCreationExpression"),
              Core.projectionField = (Core.Name "expressions")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "rankSpecifiers"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NonArrayTypeArrayCreationExpression"),
              Core.projectionField = (Core.Name "initializer")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

nonArrayTypeArrayCreationExpressionWithType :: Phantoms.TTerm Syntax.NonArrayTypeArrayCreationExpression -> Phantoms.TTerm Syntax.NonArrayType -> Phantoms.TTerm Syntax.NonArrayTypeArrayCreationExpression
nonArrayTypeArrayCreationExpressionWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NonArrayTypeArrayCreationExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "expressions"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NonArrayTypeArrayCreationExpression"),
              Core.projectionField = (Core.Name "expressions")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "rankSpecifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NonArrayTypeArrayCreationExpression"),
              Core.projectionField = (Core.Name "rankSpecifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NonArrayTypeArrayCreationExpression"),
              Core.projectionField = (Core.Name "initializer")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

nonArrayTypeClass :: Phantoms.TTerm Syntax.ClassType -> Phantoms.TTerm Syntax.NonArrayType
nonArrayTypeClass x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.NonArrayType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "class"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

nonArrayTypeDelegate :: Phantoms.TTerm Syntax.DelegateType -> Phantoms.TTerm Syntax.NonArrayType
nonArrayTypeDelegate x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.NonArrayType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "delegate"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

nonArrayTypeDynamic :: Phantoms.TTerm Syntax.NonArrayType
nonArrayTypeDynamic =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.NonArrayType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "dynamic"),
        Core.fieldTerm = Core.TermUnit}}))

nonArrayTypeInterface :: Phantoms.TTerm Syntax.InterfaceType -> Phantoms.TTerm Syntax.NonArrayType
nonArrayTypeInterface x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.NonArrayType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "interface"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

nonArrayTypeParameter :: Phantoms.TTerm Syntax.TypeParameter -> Phantoms.TTerm Syntax.NonArrayType
nonArrayTypeParameter x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.NonArrayType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "parameter"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

nonArrayTypePointer :: Phantoms.TTerm Syntax.PointerType -> Phantoms.TTerm Syntax.NonArrayType
nonArrayTypePointer x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.NonArrayType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "pointer"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

nonArrayTypeValue :: Phantoms.TTerm Syntax.ValueType -> Phantoms.TTerm Syntax.NonArrayType
nonArrayTypeValue x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.NonArrayType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "value"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

nonAssignmentExpressionConditional :: Phantoms.TTerm Syntax.ConditionalExpression -> Phantoms.TTerm Syntax.NonAssignmentExpression
nonAssignmentExpressionConditional x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.NonAssignmentExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "conditional"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

nonAssignmentExpressionDeclaration :: Phantoms.TTerm Syntax.DeclarationExpression -> Phantoms.TTerm Syntax.NonAssignmentExpression
nonAssignmentExpressionDeclaration x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.NonAssignmentExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "declaration"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

nonAssignmentExpressionLambda :: Phantoms.TTerm Syntax.LambdaExpression -> Phantoms.TTerm Syntax.NonAssignmentExpression
nonAssignmentExpressionLambda x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.NonAssignmentExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "lambda"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

nonAssignmentExpressionQuery :: Phantoms.TTerm Syntax.QueryExpression -> Phantoms.TTerm Syntax.NonAssignmentExpression
nonAssignmentExpressionQuery x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.NonAssignmentExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "query"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

nullCoalescingExpressionBinary :: Phantoms.TTerm Syntax.BinaryNullCoalescingExpression -> Phantoms.TTerm Syntax.NullCoalescingExpression
nullCoalescingExpressionBinary x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.NullCoalescingExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "binary"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

nullCoalescingExpressionSimple :: Phantoms.TTerm Syntax.ConditionalOrExpression -> Phantoms.TTerm Syntax.NullCoalescingExpression
nullCoalescingExpressionSimple x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.NullCoalescingExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "simple"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

nullCoalescingExpressionThrow :: Phantoms.TTerm Syntax.NullCoalescingExpression -> Phantoms.TTerm Syntax.NullCoalescingExpression
nullCoalescingExpressionThrow x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.NullCoalescingExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "throw"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

nullConditionalElementAccess :: Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression -> Phantoms.TTerm Syntax.ArgumentList -> Phantoms.TTerm [Syntax.DependentAccess] -> Phantoms.TTerm Syntax.NullConditionalElementAccess
nullConditionalElementAccess expression arguments dependentAccess =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalElementAccess"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm expression)},
        Core.Field {
          Core.fieldName = (Core.Name "arguments"),
          Core.fieldTerm = (Phantoms.unTTerm arguments)},
        Core.Field {
          Core.fieldName = (Core.Name "dependentAccess"),
          Core.fieldTerm = (Phantoms.unTTerm dependentAccess)}]}))

nullConditionalElementAccessArguments :: Phantoms.TTerm Syntax.NullConditionalElementAccess -> Phantoms.TTerm Syntax.ArgumentList
nullConditionalElementAccessArguments x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalElementAccess"),
        Core.projectionField = (Core.Name "arguments")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

nullConditionalElementAccessDependentAccess :: Phantoms.TTerm Syntax.NullConditionalElementAccess -> Phantoms.TTerm [Syntax.DependentAccess]
nullConditionalElementAccessDependentAccess x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalElementAccess"),
        Core.projectionField = (Core.Name "dependentAccess")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

nullConditionalElementAccessExpression :: Phantoms.TTerm Syntax.NullConditionalElementAccess -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression
nullConditionalElementAccessExpression x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalElementAccess"),
        Core.projectionField = (Core.Name "expression")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

nullConditionalElementAccessWithArguments :: Phantoms.TTerm Syntax.NullConditionalElementAccess -> Phantoms.TTerm Syntax.ArgumentList -> Phantoms.TTerm Syntax.NullConditionalElementAccess
nullConditionalElementAccessWithArguments original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalElementAccess"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalElementAccess"),
              Core.projectionField = (Core.Name "expression")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "arguments"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "dependentAccess"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalElementAccess"),
              Core.projectionField = (Core.Name "dependentAccess")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

nullConditionalElementAccessWithDependentAccess :: Phantoms.TTerm Syntax.NullConditionalElementAccess -> Phantoms.TTerm [Syntax.DependentAccess] -> Phantoms.TTerm Syntax.NullConditionalElementAccess
nullConditionalElementAccessWithDependentAccess original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalElementAccess"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalElementAccess"),
              Core.projectionField = (Core.Name "expression")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "arguments"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalElementAccess"),
              Core.projectionField = (Core.Name "arguments")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "dependentAccess"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

nullConditionalElementAccessWithExpression :: Phantoms.TTerm Syntax.NullConditionalElementAccess -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression -> Phantoms.TTerm Syntax.NullConditionalElementAccess
nullConditionalElementAccessWithExpression original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalElementAccess"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "arguments"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalElementAccess"),
              Core.projectionField = (Core.Name "arguments")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "dependentAccess"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalElementAccess"),
              Core.projectionField = (Core.Name "dependentAccess")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

nullConditionalInvocationExpression :: Phantoms.TTerm Syntax.NullConditionalInvocationExpressionHead -> Phantoms.TTerm (Maybe Syntax.ArgumentList) -> Phantoms.TTerm Syntax.NullConditionalInvocationExpression
nullConditionalInvocationExpression head arguments =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalInvocationExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "head"),
          Core.fieldTerm = (Phantoms.unTTerm head)},
        Core.Field {
          Core.fieldName = (Core.Name "arguments"),
          Core.fieldTerm = (Phantoms.unTTerm arguments)}]}))

nullConditionalInvocationExpressionArguments :: Phantoms.TTerm Syntax.NullConditionalInvocationExpression -> Phantoms.TTerm (Maybe Syntax.ArgumentList)
nullConditionalInvocationExpressionArguments x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalInvocationExpression"),
        Core.projectionField = (Core.Name "arguments")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

nullConditionalInvocationExpressionHead :: Phantoms.TTerm Syntax.NullConditionalInvocationExpression -> Phantoms.TTerm Syntax.NullConditionalInvocationExpressionHead
nullConditionalInvocationExpressionHead x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalInvocationExpression"),
        Core.projectionField = (Core.Name "head")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

nullConditionalInvocationExpressionHeadElement :: Phantoms.TTerm Syntax.NullConditionalElementAccess -> Phantoms.TTerm Syntax.NullConditionalInvocationExpressionHead
nullConditionalInvocationExpressionHeadElement x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalInvocationExpressionHead"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "element"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

nullConditionalInvocationExpressionHeadMember :: Phantoms.TTerm Syntax.NullConditionalMemberAccess -> Phantoms.TTerm Syntax.NullConditionalInvocationExpressionHead
nullConditionalInvocationExpressionHeadMember x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalInvocationExpressionHead"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "member"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

nullConditionalInvocationExpressionWithArguments :: Phantoms.TTerm Syntax.NullConditionalInvocationExpression -> Phantoms.TTerm (Maybe Syntax.ArgumentList) -> Phantoms.TTerm Syntax.NullConditionalInvocationExpression
nullConditionalInvocationExpressionWithArguments original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalInvocationExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "head"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalInvocationExpression"),
              Core.projectionField = (Core.Name "head")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "arguments"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

nullConditionalInvocationExpressionWithHead :: Phantoms.TTerm Syntax.NullConditionalInvocationExpression -> Phantoms.TTerm Syntax.NullConditionalInvocationExpressionHead -> Phantoms.TTerm Syntax.NullConditionalInvocationExpression
nullConditionalInvocationExpressionWithHead original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalInvocationExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "head"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "arguments"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalInvocationExpression"),
              Core.projectionField = (Core.Name "arguments")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

nullConditionalMemberAccess :: Phantoms.TTerm Syntax.PrimaryExpression -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList) -> Phantoms.TTerm [Syntax.DependentAccess] -> Phantoms.TTerm Syntax.NullConditionalMemberAccess
nullConditionalMemberAccess expression identifier typeArguments dependentAccess =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalMemberAccess"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm expression)},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm identifier)},
        Core.Field {
          Core.fieldName = (Core.Name "typeArguments"),
          Core.fieldTerm = (Phantoms.unTTerm typeArguments)},
        Core.Field {
          Core.fieldName = (Core.Name "dependentAccess"),
          Core.fieldTerm = (Phantoms.unTTerm dependentAccess)}]}))

nullConditionalMemberAccessDependentAccess :: Phantoms.TTerm Syntax.NullConditionalMemberAccess -> Phantoms.TTerm [Syntax.DependentAccess]
nullConditionalMemberAccessDependentAccess x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalMemberAccess"),
        Core.projectionField = (Core.Name "dependentAccess")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

nullConditionalMemberAccessExpression :: Phantoms.TTerm Syntax.NullConditionalMemberAccess -> Phantoms.TTerm Syntax.PrimaryExpression
nullConditionalMemberAccessExpression x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalMemberAccess"),
        Core.projectionField = (Core.Name "expression")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

nullConditionalMemberAccessIdentifier :: Phantoms.TTerm Syntax.NullConditionalMemberAccess -> Phantoms.TTerm Syntax.Identifier
nullConditionalMemberAccessIdentifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalMemberAccess"),
        Core.projectionField = (Core.Name "identifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

nullConditionalMemberAccessTypeArguments :: Phantoms.TTerm Syntax.NullConditionalMemberAccess -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList)
nullConditionalMemberAccessTypeArguments x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalMemberAccess"),
        Core.projectionField = (Core.Name "typeArguments")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

nullConditionalMemberAccessWithDependentAccess :: Phantoms.TTerm Syntax.NullConditionalMemberAccess -> Phantoms.TTerm [Syntax.DependentAccess] -> Phantoms.TTerm Syntax.NullConditionalMemberAccess
nullConditionalMemberAccessWithDependentAccess original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalMemberAccess"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalMemberAccess"),
              Core.projectionField = (Core.Name "expression")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalMemberAccess"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "typeArguments"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalMemberAccess"),
              Core.projectionField = (Core.Name "typeArguments")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "dependentAccess"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

nullConditionalMemberAccessWithExpression :: Phantoms.TTerm Syntax.NullConditionalMemberAccess -> Phantoms.TTerm Syntax.PrimaryExpression -> Phantoms.TTerm Syntax.NullConditionalMemberAccess
nullConditionalMemberAccessWithExpression original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalMemberAccess"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalMemberAccess"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "typeArguments"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalMemberAccess"),
              Core.projectionField = (Core.Name "typeArguments")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "dependentAccess"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalMemberAccess"),
              Core.projectionField = (Core.Name "dependentAccess")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

nullConditionalMemberAccessWithIdentifier :: Phantoms.TTerm Syntax.NullConditionalMemberAccess -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.NullConditionalMemberAccess
nullConditionalMemberAccessWithIdentifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalMemberAccess"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalMemberAccess"),
              Core.projectionField = (Core.Name "expression")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "typeArguments"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalMemberAccess"),
              Core.projectionField = (Core.Name "typeArguments")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "dependentAccess"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalMemberAccess"),
              Core.projectionField = (Core.Name "dependentAccess")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

nullConditionalMemberAccessWithTypeArguments :: Phantoms.TTerm Syntax.NullConditionalMemberAccess -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList) -> Phantoms.TTerm Syntax.NullConditionalMemberAccess
nullConditionalMemberAccessWithTypeArguments original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalMemberAccess"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalMemberAccess"),
              Core.projectionField = (Core.Name "expression")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalMemberAccess"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "typeArguments"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "dependentAccess"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalMemberAccess"),
              Core.projectionField = (Core.Name "dependentAccess")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

nullConditionalProjectionInitializer :: Phantoms.TTerm Syntax.PrimaryExpression -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList) -> Phantoms.TTerm Syntax.NullConditionalProjectionInitializer
nullConditionalProjectionInitializer expression identifier typeArguments =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalProjectionInitializer"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm expression)},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm identifier)},
        Core.Field {
          Core.fieldName = (Core.Name "typeArguments"),
          Core.fieldTerm = (Phantoms.unTTerm typeArguments)}]}))

nullConditionalProjectionInitializerExpression :: Phantoms.TTerm Syntax.NullConditionalProjectionInitializer -> Phantoms.TTerm Syntax.PrimaryExpression
nullConditionalProjectionInitializerExpression x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalProjectionInitializer"),
        Core.projectionField = (Core.Name "expression")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

nullConditionalProjectionInitializerIdentifier :: Phantoms.TTerm Syntax.NullConditionalProjectionInitializer -> Phantoms.TTerm Syntax.Identifier
nullConditionalProjectionInitializerIdentifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalProjectionInitializer"),
        Core.projectionField = (Core.Name "identifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

nullConditionalProjectionInitializerTypeArguments :: Phantoms.TTerm Syntax.NullConditionalProjectionInitializer -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList)
nullConditionalProjectionInitializerTypeArguments x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalProjectionInitializer"),
        Core.projectionField = (Core.Name "typeArguments")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

nullConditionalProjectionInitializerWithExpression :: Phantoms.TTerm Syntax.NullConditionalProjectionInitializer -> Phantoms.TTerm Syntax.PrimaryExpression -> Phantoms.TTerm Syntax.NullConditionalProjectionInitializer
nullConditionalProjectionInitializerWithExpression original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalProjectionInitializer"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalProjectionInitializer"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "typeArguments"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalProjectionInitializer"),
              Core.projectionField = (Core.Name "typeArguments")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

nullConditionalProjectionInitializerWithIdentifier :: Phantoms.TTerm Syntax.NullConditionalProjectionInitializer -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.NullConditionalProjectionInitializer
nullConditionalProjectionInitializerWithIdentifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalProjectionInitializer"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalProjectionInitializer"),
              Core.projectionField = (Core.Name "expression")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "typeArguments"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalProjectionInitializer"),
              Core.projectionField = (Core.Name "typeArguments")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

nullConditionalProjectionInitializerWithTypeArguments :: Phantoms.TTerm Syntax.NullConditionalProjectionInitializer -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList) -> Phantoms.TTerm Syntax.NullConditionalProjectionInitializer
nullConditionalProjectionInitializerWithTypeArguments original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalProjectionInitializer"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalProjectionInitializer"),
              Core.projectionField = (Core.Name "expression")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.NullConditionalProjectionInitializer"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "typeArguments"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

numericTypeDecimal :: Phantoms.TTerm Syntax.NumericType
numericTypeDecimal =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.NumericType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "decimal"),
        Core.fieldTerm = Core.TermUnit}}))

numericTypeFloatingPoint :: Phantoms.TTerm Syntax.FloatingPointType -> Phantoms.TTerm Syntax.NumericType
numericTypeFloatingPoint x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.NumericType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "floatingPoint"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

numericTypeIntegral :: Phantoms.TTerm Syntax.IntegralType -> Phantoms.TTerm Syntax.NumericType
numericTypeIntegral x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.NumericType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "integral"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

objectCreationExpression :: Phantoms.TTerm Syntax.Type -> Phantoms.TTerm (Maybe Syntax.ArgumentList) -> Phantoms.TTerm (Maybe Syntax.ObjectOrCollectionInitializer) -> Phantoms.TTerm Syntax.ObjectCreationExpression
objectCreationExpression type_ arguments initializer =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ObjectCreationExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "arguments"),
          Core.fieldTerm = (Phantoms.unTTerm arguments)},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Phantoms.unTTerm initializer)}]}))

objectCreationExpressionArguments :: Phantoms.TTerm Syntax.ObjectCreationExpression -> Phantoms.TTerm (Maybe Syntax.ArgumentList)
objectCreationExpressionArguments x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ObjectCreationExpression"),
        Core.projectionField = (Core.Name "arguments")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

objectCreationExpressionInitializer :: Phantoms.TTerm Syntax.ObjectCreationExpression -> Phantoms.TTerm (Maybe Syntax.ObjectOrCollectionInitializer)
objectCreationExpressionInitializer x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ObjectCreationExpression"),
        Core.projectionField = (Core.Name "initializer")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

objectCreationExpressionType :: Phantoms.TTerm Syntax.ObjectCreationExpression -> Phantoms.TTerm Syntax.Type
objectCreationExpressionType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ObjectCreationExpression"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

objectCreationExpressionWithArguments :: Phantoms.TTerm Syntax.ObjectCreationExpression -> Phantoms.TTerm (Maybe Syntax.ArgumentList) -> Phantoms.TTerm Syntax.ObjectCreationExpression
objectCreationExpressionWithArguments original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ObjectCreationExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ObjectCreationExpression"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "arguments"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ObjectCreationExpression"),
              Core.projectionField = (Core.Name "initializer")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

objectCreationExpressionWithInitializer :: Phantoms.TTerm Syntax.ObjectCreationExpression -> Phantoms.TTerm (Maybe Syntax.ObjectOrCollectionInitializer) -> Phantoms.TTerm Syntax.ObjectCreationExpression
objectCreationExpressionWithInitializer original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ObjectCreationExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ObjectCreationExpression"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "arguments"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ObjectCreationExpression"),
              Core.projectionField = (Core.Name "arguments")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

objectCreationExpressionWithType :: Phantoms.TTerm Syntax.ObjectCreationExpression -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.ObjectCreationExpression
objectCreationExpressionWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ObjectCreationExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "arguments"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ObjectCreationExpression"),
              Core.projectionField = (Core.Name "arguments")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ObjectCreationExpression"),
              Core.projectionField = (Core.Name "initializer")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

objectOrCollectionInitializerCollection :: Phantoms.TTerm [Syntax.ElementInitializer] -> Phantoms.TTerm Syntax.ObjectOrCollectionInitializer
objectOrCollectionInitializerCollection x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ObjectOrCollectionInitializer"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "collection"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

objectOrCollectionInitializerObject :: Phantoms.TTerm [Syntax.MemberInitializer] -> Phantoms.TTerm Syntax.ObjectOrCollectionInitializer
objectOrCollectionInitializerObject x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ObjectOrCollectionInitializer"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "object"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

operatorBodyBlock :: Phantoms.TTerm Syntax.Block -> Phantoms.TTerm Syntax.OperatorBody
operatorBodyBlock x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OperatorBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "block"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

operatorBodyEmpty :: Phantoms.TTerm Syntax.OperatorBody
operatorBodyEmpty =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OperatorBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "empty"),
        Core.fieldTerm = Core.TermUnit}}))

operatorBodyExpression :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.OperatorBody
operatorBodyExpression x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OperatorBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "expression"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

operatorDeclaration :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm [Syntax.OperatorModifier] -> Phantoms.TTerm Syntax.OperatorDeclarator -> Phantoms.TTerm Syntax.OperatorBody -> Phantoms.TTerm Syntax.OperatorDeclaration
operatorDeclaration attributes modifiers declarator body =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.OperatorDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm modifiers)},
        Core.Field {
          Core.fieldName = (Core.Name "declarator"),
          Core.fieldTerm = (Phantoms.unTTerm declarator)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)}]}))

operatorDeclarationAttributes :: Phantoms.TTerm Syntax.OperatorDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes)
operatorDeclarationAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.OperatorDeclaration"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

operatorDeclarationBody :: Phantoms.TTerm Syntax.OperatorDeclaration -> Phantoms.TTerm Syntax.OperatorBody
operatorDeclarationBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.OperatorDeclaration"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

operatorDeclarationDeclarator :: Phantoms.TTerm Syntax.OperatorDeclaration -> Phantoms.TTerm Syntax.OperatorDeclarator
operatorDeclarationDeclarator x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.OperatorDeclaration"),
        Core.projectionField = (Core.Name "declarator")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

operatorDeclarationModifiers :: Phantoms.TTerm Syntax.OperatorDeclaration -> Phantoms.TTerm [Syntax.OperatorModifier]
operatorDeclarationModifiers x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.OperatorDeclaration"),
        Core.projectionField = (Core.Name "modifiers")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

operatorDeclarationWithAttributes :: Phantoms.TTerm Syntax.OperatorDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.OperatorDeclaration
operatorDeclarationWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.OperatorDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.OperatorDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.OperatorDeclaration"),
              Core.projectionField = (Core.Name "declarator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.OperatorDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

operatorDeclarationWithBody :: Phantoms.TTerm Syntax.OperatorDeclaration -> Phantoms.TTerm Syntax.OperatorBody -> Phantoms.TTerm Syntax.OperatorDeclaration
operatorDeclarationWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.OperatorDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.OperatorDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.OperatorDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.OperatorDeclaration"),
              Core.projectionField = (Core.Name "declarator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

operatorDeclarationWithDeclarator :: Phantoms.TTerm Syntax.OperatorDeclaration -> Phantoms.TTerm Syntax.OperatorDeclarator -> Phantoms.TTerm Syntax.OperatorDeclaration
operatorDeclarationWithDeclarator original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.OperatorDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.OperatorDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.OperatorDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarator"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.OperatorDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

operatorDeclarationWithModifiers :: Phantoms.TTerm Syntax.OperatorDeclaration -> Phantoms.TTerm [Syntax.OperatorModifier] -> Phantoms.TTerm Syntax.OperatorDeclaration
operatorDeclarationWithModifiers original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.OperatorDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.OperatorDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "declarator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.OperatorDeclaration"),
              Core.projectionField = (Core.Name "declarator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.OperatorDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

operatorDeclaratorBinary :: Phantoms.TTerm Syntax.BinaryOperatorDeclarator -> Phantoms.TTerm Syntax.OperatorDeclarator
operatorDeclaratorBinary x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OperatorDeclarator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "binary"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

operatorDeclaratorConversion :: Phantoms.TTerm Syntax.ConversionOperatorDeclarator -> Phantoms.TTerm Syntax.OperatorDeclarator
operatorDeclaratorConversion x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OperatorDeclarator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "conversion"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

operatorDeclaratorUnary :: Phantoms.TTerm Syntax.UnaryOperatorDeclarator -> Phantoms.TTerm Syntax.OperatorDeclarator
operatorDeclaratorUnary x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OperatorDeclarator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "unary"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

operatorModifierExtern :: Phantoms.TTerm Syntax.OperatorModifier
operatorModifierExtern =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OperatorModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "extern"),
        Core.fieldTerm = Core.TermUnit}}))

operatorModifierPublic :: Phantoms.TTerm Syntax.OperatorModifier
operatorModifierPublic =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OperatorModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "public"),
        Core.fieldTerm = Core.TermUnit}}))

operatorModifierStatic :: Phantoms.TTerm Syntax.OperatorModifier
operatorModifierStatic =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OperatorModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "static"),
        Core.fieldTerm = Core.TermUnit}}))

operatorModifierUnsafe :: Phantoms.TTerm Syntax.OperatorModifier
operatorModifierUnsafe =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OperatorModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "unsafe"),
        Core.fieldTerm = Core.TermUnit}}))

ordering :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm (Maybe Syntax.OrderingDirection) -> Phantoms.TTerm Syntax.Ordering
ordering expression direction =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.Ordering"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm expression)},
        Core.Field {
          Core.fieldName = (Core.Name "direction"),
          Core.fieldTerm = (Phantoms.unTTerm direction)}]}))

orderingDirection :: Phantoms.TTerm Syntax.Ordering -> Phantoms.TTerm (Maybe Syntax.OrderingDirection)
orderingDirection x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.Ordering"),
        Core.projectionField = (Core.Name "direction")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

orderingDirectionAscending :: Phantoms.TTerm Syntax.OrderingDirection
orderingDirectionAscending =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OrderingDirection"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "ascending"),
        Core.fieldTerm = Core.TermUnit}}))

orderingDirectionDescending :: Phantoms.TTerm Syntax.OrderingDirection
orderingDirectionDescending =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OrderingDirection"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "descending"),
        Core.fieldTerm = Core.TermUnit}}))

orderingExpression :: Phantoms.TTerm Syntax.Ordering -> Phantoms.TTerm Syntax.Expression
orderingExpression x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.Ordering"),
        Core.projectionField = (Core.Name "expression")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

orderingWithDirection :: Phantoms.TTerm Syntax.Ordering -> Phantoms.TTerm (Maybe Syntax.OrderingDirection) -> Phantoms.TTerm Syntax.Ordering
orderingWithDirection original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.Ordering"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.Ordering"),
              Core.projectionField = (Core.Name "expression")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "direction"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

orderingWithExpression :: Phantoms.TTerm Syntax.Ordering -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.Ordering
orderingWithExpression original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.Ordering"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "direction"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.Ordering"),
              Core.projectionField = (Core.Name "direction")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

overloadableBinaryOperatorAdd :: Phantoms.TTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorAdd =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OverloadableBinaryOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "add"),
        Core.fieldTerm = Core.TermUnit}}))

overloadableBinaryOperatorAnd :: Phantoms.TTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorAnd =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OverloadableBinaryOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "and"),
        Core.fieldTerm = Core.TermUnit}}))

overloadableBinaryOperatorDivide :: Phantoms.TTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorDivide =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OverloadableBinaryOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "divide"),
        Core.fieldTerm = Core.TermUnit}}))

overloadableBinaryOperatorEqual :: Phantoms.TTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorEqual =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OverloadableBinaryOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "equal"),
        Core.fieldTerm = Core.TermUnit}}))

overloadableBinaryOperatorGreaterThan :: Phantoms.TTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorGreaterThan =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OverloadableBinaryOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "greaterThan"),
        Core.fieldTerm = Core.TermUnit}}))

overloadableBinaryOperatorGreaterThanOrEqual :: Phantoms.TTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorGreaterThanOrEqual =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OverloadableBinaryOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "greaterThanOrEqual"),
        Core.fieldTerm = Core.TermUnit}}))

overloadableBinaryOperatorLeftShift :: Phantoms.TTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorLeftShift =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OverloadableBinaryOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "leftShift"),
        Core.fieldTerm = Core.TermUnit}}))

overloadableBinaryOperatorLessThan :: Phantoms.TTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorLessThan =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OverloadableBinaryOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "lessThan"),
        Core.fieldTerm = Core.TermUnit}}))

overloadableBinaryOperatorLessThanOrEqual :: Phantoms.TTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorLessThanOrEqual =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OverloadableBinaryOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "lessThanOrEqual"),
        Core.fieldTerm = Core.TermUnit}}))

overloadableBinaryOperatorModulus :: Phantoms.TTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorModulus =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OverloadableBinaryOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "modulus"),
        Core.fieldTerm = Core.TermUnit}}))

overloadableBinaryOperatorMultiply :: Phantoms.TTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorMultiply =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OverloadableBinaryOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "multiply"),
        Core.fieldTerm = Core.TermUnit}}))

overloadableBinaryOperatorNotEqual :: Phantoms.TTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorNotEqual =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OverloadableBinaryOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "notEqual"),
        Core.fieldTerm = Core.TermUnit}}))

overloadableBinaryOperatorOr :: Phantoms.TTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorOr =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OverloadableBinaryOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "or"),
        Core.fieldTerm = Core.TermUnit}}))

overloadableBinaryOperatorRightShift :: Phantoms.TTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorRightShift =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OverloadableBinaryOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "rightShift"),
        Core.fieldTerm = Core.TermUnit}}))

overloadableBinaryOperatorSubtract :: Phantoms.TTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorSubtract =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OverloadableBinaryOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "subtract"),
        Core.fieldTerm = Core.TermUnit}}))

overloadableBinaryOperatorXor :: Phantoms.TTerm Syntax.OverloadableBinaryOperator
overloadableBinaryOperatorXor =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OverloadableBinaryOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "xor"),
        Core.fieldTerm = Core.TermUnit}}))

overloadableUnaryOperatorComplement :: Phantoms.TTerm Syntax.OverloadableUnaryOperator
overloadableUnaryOperatorComplement =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OverloadableUnaryOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "complement"),
        Core.fieldTerm = Core.TermUnit}}))

overloadableUnaryOperatorDecrement :: Phantoms.TTerm Syntax.OverloadableUnaryOperator
overloadableUnaryOperatorDecrement =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OverloadableUnaryOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "decrement"),
        Core.fieldTerm = Core.TermUnit}}))

overloadableUnaryOperatorFalse :: Phantoms.TTerm Syntax.OverloadableUnaryOperator
overloadableUnaryOperatorFalse =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OverloadableUnaryOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "false"),
        Core.fieldTerm = Core.TermUnit}}))

overloadableUnaryOperatorIncrement :: Phantoms.TTerm Syntax.OverloadableUnaryOperator
overloadableUnaryOperatorIncrement =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OverloadableUnaryOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "increment"),
        Core.fieldTerm = Core.TermUnit}}))

overloadableUnaryOperatorMinus :: Phantoms.TTerm Syntax.OverloadableUnaryOperator
overloadableUnaryOperatorMinus =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OverloadableUnaryOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "minus"),
        Core.fieldTerm = Core.TermUnit}}))

overloadableUnaryOperatorNot :: Phantoms.TTerm Syntax.OverloadableUnaryOperator
overloadableUnaryOperatorNot =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OverloadableUnaryOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "not"),
        Core.fieldTerm = Core.TermUnit}}))

overloadableUnaryOperatorPlus :: Phantoms.TTerm Syntax.OverloadableUnaryOperator
overloadableUnaryOperatorPlus =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OverloadableUnaryOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "plus"),
        Core.fieldTerm = Core.TermUnit}}))

overloadableUnaryOperatorTrue :: Phantoms.TTerm Syntax.OverloadableUnaryOperator
overloadableUnaryOperatorTrue =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.OverloadableUnaryOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "true"),
        Core.fieldTerm = Core.TermUnit}}))

parameterArray :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.ArrayType -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.ParameterArray
parameterArray attributes type_ identifier =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ParameterArray"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm identifier)}]}))

parameterArrayAttributes :: Phantoms.TTerm Syntax.ParameterArray -> Phantoms.TTerm (Maybe Syntax.Attributes)
parameterArrayAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ParameterArray"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

parameterArrayIdentifier :: Phantoms.TTerm Syntax.ParameterArray -> Phantoms.TTerm Syntax.Identifier
parameterArrayIdentifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ParameterArray"),
        Core.projectionField = (Core.Name "identifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

parameterArrayType :: Phantoms.TTerm Syntax.ParameterArray -> Phantoms.TTerm Syntax.ArrayType
parameterArrayType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ParameterArray"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

parameterArrayWithAttributes :: Phantoms.TTerm Syntax.ParameterArray -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.ParameterArray
parameterArrayWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ParameterArray"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ParameterArray"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ParameterArray"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

parameterArrayWithIdentifier :: Phantoms.TTerm Syntax.ParameterArray -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.ParameterArray
parameterArrayWithIdentifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ParameterArray"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ParameterArray"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ParameterArray"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

parameterArrayWithType :: Phantoms.TTerm Syntax.ParameterArray -> Phantoms.TTerm Syntax.ArrayType -> Phantoms.TTerm Syntax.ParameterArray
parameterArrayWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.ParameterArray"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ParameterArray"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.ParameterArray"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

parameterModeModifierIn :: Phantoms.TTerm Syntax.ParameterModeModifier
parameterModeModifierIn =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ParameterModeModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "in"),
        Core.fieldTerm = Core.TermUnit}}))

parameterModeModifierOut :: Phantoms.TTerm Syntax.ParameterModeModifier
parameterModeModifierOut =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ParameterModeModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "out"),
        Core.fieldTerm = Core.TermUnit}}))

parameterModeModifierRef :: Phantoms.TTerm Syntax.ParameterModeModifier
parameterModeModifierRef =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ParameterModeModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "ref"),
        Core.fieldTerm = Core.TermUnit}}))

parameterModifierMode :: Phantoms.TTerm Syntax.ParameterModeModifier -> Phantoms.TTerm Syntax.ParameterModifier
parameterModifierMode x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ParameterModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "mode"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

parameterModifierThis :: Phantoms.TTerm Syntax.ParameterModifier
parameterModifierThis =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ParameterModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "this"),
        Core.fieldTerm = Core.TermUnit}}))

patternConstant :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.Pattern
patternConstant x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.Pattern"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "constant"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

patternDeclaration :: Phantoms.TTerm Syntax.DeclarationPattern -> Phantoms.TTerm Syntax.Pattern
patternDeclaration x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.Pattern"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "declaration"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

patternVar :: Phantoms.TTerm Syntax.Designation -> Phantoms.TTerm Syntax.Pattern
patternVar x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.Pattern"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "var"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

pointerElementAccess :: Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.PointerElementAccess
pointerElementAccess pointer index =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.PointerElementAccess"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "pointer"),
          Core.fieldTerm = (Phantoms.unTTerm pointer)},
        Core.Field {
          Core.fieldName = (Core.Name "index"),
          Core.fieldTerm = (Phantoms.unTTerm index)}]}))

pointerElementAccessIndex :: Phantoms.TTerm Syntax.PointerElementAccess -> Phantoms.TTerm Syntax.Expression
pointerElementAccessIndex x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.PointerElementAccess"),
        Core.projectionField = (Core.Name "index")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

pointerElementAccessPointer :: Phantoms.TTerm Syntax.PointerElementAccess -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression
pointerElementAccessPointer x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.PointerElementAccess"),
        Core.projectionField = (Core.Name "pointer")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

pointerElementAccessWithIndex :: Phantoms.TTerm Syntax.PointerElementAccess -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.PointerElementAccess
pointerElementAccessWithIndex original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.PointerElementAccess"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "pointer"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.PointerElementAccess"),
              Core.projectionField = (Core.Name "pointer")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "index"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

pointerElementAccessWithPointer :: Phantoms.TTerm Syntax.PointerElementAccess -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression -> Phantoms.TTerm Syntax.PointerElementAccess
pointerElementAccessWithPointer original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.PointerElementAccess"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "pointer"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "index"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.PointerElementAccess"),
              Core.projectionField = (Core.Name "index")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

pointerMemberAccess :: Phantoms.TTerm Syntax.PrimaryExpression -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList) -> Phantoms.TTerm Syntax.PointerMemberAccess
pointerMemberAccess pointer member typeArguments =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.PointerMemberAccess"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "pointer"),
          Core.fieldTerm = (Phantoms.unTTerm pointer)},
        Core.Field {
          Core.fieldName = (Core.Name "member"),
          Core.fieldTerm = (Phantoms.unTTerm member)},
        Core.Field {
          Core.fieldName = (Core.Name "typeArguments"),
          Core.fieldTerm = (Phantoms.unTTerm typeArguments)}]}))

pointerMemberAccessMember :: Phantoms.TTerm Syntax.PointerMemberAccess -> Phantoms.TTerm Syntax.Identifier
pointerMemberAccessMember x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.PointerMemberAccess"),
        Core.projectionField = (Core.Name "member")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

pointerMemberAccessPointer :: Phantoms.TTerm Syntax.PointerMemberAccess -> Phantoms.TTerm Syntax.PrimaryExpression
pointerMemberAccessPointer x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.PointerMemberAccess"),
        Core.projectionField = (Core.Name "pointer")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

pointerMemberAccessTypeArguments :: Phantoms.TTerm Syntax.PointerMemberAccess -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList)
pointerMemberAccessTypeArguments x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.PointerMemberAccess"),
        Core.projectionField = (Core.Name "typeArguments")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

pointerMemberAccessWithMember :: Phantoms.TTerm Syntax.PointerMemberAccess -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.PointerMemberAccess
pointerMemberAccessWithMember original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.PointerMemberAccess"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "pointer"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.PointerMemberAccess"),
              Core.projectionField = (Core.Name "pointer")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "member"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "typeArguments"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.PointerMemberAccess"),
              Core.projectionField = (Core.Name "typeArguments")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

pointerMemberAccessWithPointer :: Phantoms.TTerm Syntax.PointerMemberAccess -> Phantoms.TTerm Syntax.PrimaryExpression -> Phantoms.TTerm Syntax.PointerMemberAccess
pointerMemberAccessWithPointer original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.PointerMemberAccess"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "pointer"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "member"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.PointerMemberAccess"),
              Core.projectionField = (Core.Name "member")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "typeArguments"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.PointerMemberAccess"),
              Core.projectionField = (Core.Name "typeArguments")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

pointerMemberAccessWithTypeArguments :: Phantoms.TTerm Syntax.PointerMemberAccess -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList) -> Phantoms.TTerm Syntax.PointerMemberAccess
pointerMemberAccessWithTypeArguments original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.PointerMemberAccess"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "pointer"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.PointerMemberAccess"),
              Core.projectionField = (Core.Name "pointer")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "member"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.PointerMemberAccess"),
              Core.projectionField = (Core.Name "member")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "typeArguments"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

pointerTypePointerDepth :: Phantoms.TTerm Int -> Phantoms.TTerm Syntax.PointerType
pointerTypePointerDepth x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PointerType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "pointerDepth"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

pointerTypeValueType :: Phantoms.TTerm (Maybe Syntax.ValueType) -> Phantoms.TTerm Syntax.PointerType
pointerTypeValueType x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PointerType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "valueType"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

positionalArgument :: Phantoms.TTerm (Maybe Syntax.Identifier) -> Phantoms.TTerm Syntax.AttributeArgumentExpression -> Phantoms.TTerm Syntax.PositionalArgument
positionalArgument name value =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.PositionalArgument"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm name)},
        Core.Field {
          Core.fieldName = (Core.Name "value"),
          Core.fieldTerm = (Phantoms.unTTerm value)}]}))

positionalArgumentList :: Phantoms.TTerm [Syntax.PositionalArgument] -> Phantoms.TTerm Syntax.PositionalArgumentList
positionalArgumentList x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.PositionalArgumentList"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

positionalArgumentName :: Phantoms.TTerm Syntax.PositionalArgument -> Phantoms.TTerm (Maybe Syntax.Identifier)
positionalArgumentName x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.PositionalArgument"),
        Core.projectionField = (Core.Name "name")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

positionalArgumentValue :: Phantoms.TTerm Syntax.PositionalArgument -> Phantoms.TTerm Syntax.AttributeArgumentExpression
positionalArgumentValue x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.PositionalArgument"),
        Core.projectionField = (Core.Name "value")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

positionalArgumentWithName :: Phantoms.TTerm Syntax.PositionalArgument -> Phantoms.TTerm (Maybe Syntax.Identifier) -> Phantoms.TTerm Syntax.PositionalArgument
positionalArgumentWithName original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.PositionalArgument"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "value"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.PositionalArgument"),
              Core.projectionField = (Core.Name "value")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

positionalArgumentWithValue :: Phantoms.TTerm Syntax.PositionalArgument -> Phantoms.TTerm Syntax.AttributeArgumentExpression -> Phantoms.TTerm Syntax.PositionalArgument
positionalArgumentWithValue original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.PositionalArgument"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.PositionalArgument"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "value"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

predefinedTypeBool :: Phantoms.TTerm Syntax.PredefinedType
predefinedTypeBool =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PredefinedType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "bool"),
        Core.fieldTerm = Core.TermUnit}}))

predefinedTypeByte :: Phantoms.TTerm Syntax.PredefinedType
predefinedTypeByte =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PredefinedType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "byte"),
        Core.fieldTerm = Core.TermUnit}}))

predefinedTypeChar :: Phantoms.TTerm Syntax.PredefinedType
predefinedTypeChar =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PredefinedType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "char"),
        Core.fieldTerm = Core.TermUnit}}))

predefinedTypeDecimal :: Phantoms.TTerm Syntax.PredefinedType
predefinedTypeDecimal =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PredefinedType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "decimal"),
        Core.fieldTerm = Core.TermUnit}}))

predefinedTypeDouble :: Phantoms.TTerm Syntax.PredefinedType
predefinedTypeDouble =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PredefinedType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "double"),
        Core.fieldTerm = Core.TermUnit}}))

predefinedTypeFloat :: Phantoms.TTerm Syntax.PredefinedType
predefinedTypeFloat =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PredefinedType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "float"),
        Core.fieldTerm = Core.TermUnit}}))

predefinedTypeInt :: Phantoms.TTerm Syntax.PredefinedType
predefinedTypeInt =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PredefinedType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "int"),
        Core.fieldTerm = Core.TermUnit}}))

predefinedTypeLong :: Phantoms.TTerm Syntax.PredefinedType
predefinedTypeLong =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PredefinedType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "long"),
        Core.fieldTerm = Core.TermUnit}}))

predefinedTypeObject :: Phantoms.TTerm Syntax.PredefinedType
predefinedTypeObject =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PredefinedType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "object"),
        Core.fieldTerm = Core.TermUnit}}))

predefinedTypeSbyte :: Phantoms.TTerm Syntax.PredefinedType
predefinedTypeSbyte =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PredefinedType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "sbyte"),
        Core.fieldTerm = Core.TermUnit}}))

predefinedTypeShort :: Phantoms.TTerm Syntax.PredefinedType
predefinedTypeShort =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PredefinedType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "short"),
        Core.fieldTerm = Core.TermUnit}}))

predefinedTypeString :: Phantoms.TTerm Syntax.PredefinedType
predefinedTypeString =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PredefinedType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "string"),
        Core.fieldTerm = Core.TermUnit}}))

predefinedTypeUint :: Phantoms.TTerm Syntax.PredefinedType
predefinedTypeUint =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PredefinedType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "uint"),
        Core.fieldTerm = Core.TermUnit}}))

predefinedTypeUlong :: Phantoms.TTerm Syntax.PredefinedType
predefinedTypeUlong =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PredefinedType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "ulong"),
        Core.fieldTerm = Core.TermUnit}}))

predefinedTypeUshort :: Phantoms.TTerm Syntax.PredefinedType
predefinedTypeUshort =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PredefinedType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "ushort"),
        Core.fieldTerm = Core.TermUnit}}))

primaryConstraintClass :: Phantoms.TTerm Syntax.PrimaryConstraint
primaryConstraintClass =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryConstraint"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "class"),
        Core.fieldTerm = Core.TermUnit}}))

primaryConstraintClassType :: Phantoms.TTerm Syntax.ClassType -> Phantoms.TTerm Syntax.PrimaryConstraint
primaryConstraintClassType x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryConstraint"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "classType"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

primaryConstraintStruct :: Phantoms.TTerm Syntax.PrimaryConstraint
primaryConstraintStruct =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryConstraint"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "struct"),
        Core.fieldTerm = Core.TermUnit}}))

primaryConstraintUnmanaged :: Phantoms.TTerm Syntax.PrimaryConstraint
primaryConstraintUnmanaged =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryConstraint"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "unmanaged"),
        Core.fieldTerm = Core.TermUnit}}))

primaryExpressionArray :: Phantoms.TTerm Syntax.ArrayCreationExpression -> Phantoms.TTerm Syntax.PrimaryExpression
primaryExpressionArray x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "array"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

primaryExpressionNoArray :: Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression -> Phantoms.TTerm Syntax.PrimaryExpression
primaryExpressionNoArray x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "noArray"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

primaryNoArrayCreationExpressionAnonymousMethod :: Phantoms.TTerm Syntax.AnonymousMethodExpression -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionAnonymousMethod x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "anonymousMethod"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

primaryNoArrayCreationExpressionAnonymousObjectCreation :: Phantoms.TTerm (Maybe Syntax.MemberDeclaratorList) -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionAnonymousObjectCreation x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "anonymousObjectCreation"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

primaryNoArrayCreationExpressionBaseAccess :: Phantoms.TTerm Syntax.BaseAccess -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionBaseAccess x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "baseAccess"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

primaryNoArrayCreationExpressionChecked :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionChecked x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "checked"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

primaryNoArrayCreationExpressionDefaultValue :: Phantoms.TTerm Syntax.DefaultValueExpression -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionDefaultValue x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "defaultValue"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

primaryNoArrayCreationExpressionDelegateCreation :: Phantoms.TTerm Syntax.DelegateCreationExpression -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionDelegateCreation x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "delegateCreation"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

primaryNoArrayCreationExpressionElementAccess :: Phantoms.TTerm Syntax.ElementAccess -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionElementAccess x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "elementAccess"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

primaryNoArrayCreationExpressionInterpolatedString :: Phantoms.TTerm Syntax.InterpolatedStringExpression -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionInterpolatedString x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "interpolatedString"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

primaryNoArrayCreationExpressionInvocation :: Phantoms.TTerm Syntax.InvocationExpression -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionInvocation x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "invocation"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

primaryNoArrayCreationExpressionLiteral :: Phantoms.TTerm Syntax.Literal -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionLiteral x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "literal"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

primaryNoArrayCreationExpressionMemberAccess :: Phantoms.TTerm Syntax.MemberAccess -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionMemberAccess x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "memberAccess"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

primaryNoArrayCreationExpressionNameof :: Phantoms.TTerm Syntax.NamedEntity -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionNameof x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "nameof"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

primaryNoArrayCreationExpressionNullConditionalElementAccess :: Phantoms.TTerm Syntax.NullConditionalElementAccess -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionNullConditionalElementAccess x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "nullConditionalElementAccess"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

primaryNoArrayCreationExpressionNullConditionalMemberAccess :: Phantoms.TTerm Syntax.NullConditionalMemberAccess -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionNullConditionalMemberAccess x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "nullConditionalMemberAccess"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

primaryNoArrayCreationExpressionObjectCreation :: Phantoms.TTerm Syntax.ObjectCreationExpression -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionObjectCreation x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "objectCreation"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

primaryNoArrayCreationExpressionParenthesized :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionParenthesized x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "parenthesized"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

primaryNoArrayCreationExpressionPointerElementAccess :: Phantoms.TTerm Syntax.PointerElementAccess -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionPointerElementAccess x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "pointerElementAccess"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

primaryNoArrayCreationExpressionPointerMemberAccess :: Phantoms.TTerm Syntax.PointerMemberAccess -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionPointerMemberAccess x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "pointerMemberAccess"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

primaryNoArrayCreationExpressionPostDecrement :: Phantoms.TTerm Syntax.PrimaryExpression -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionPostDecrement x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "postDecrement"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

primaryNoArrayCreationExpressionPostIncrement :: Phantoms.TTerm Syntax.PrimaryExpression -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionPostIncrement x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "postIncrement"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

primaryNoArrayCreationExpressionSimpleName :: Phantoms.TTerm Syntax.SimpleName -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionSimpleName x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "simpleName"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

primaryNoArrayCreationExpressionSizeof :: Phantoms.TTerm Syntax.UnmanagedType -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionSizeof x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "sizeof"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

primaryNoArrayCreationExpressionStackalloc :: Phantoms.TTerm Syntax.StackallocExpression -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionStackalloc x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "stackalloc"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

primaryNoArrayCreationExpressionThisAccess :: Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionThisAccess =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "thisAccess"),
        Core.fieldTerm = Core.TermUnit}}))

primaryNoArrayCreationExpressionTuple :: Phantoms.TTerm Syntax.TupleExpression -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionTuple x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "tuple"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

primaryNoArrayCreationExpressionTypeof :: Phantoms.TTerm Syntax.TypeofExpression -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionTypeof x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "typeof"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

primaryNoArrayCreationExpressionUnchecked :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.PrimaryNoArrayCreationExpression
primaryNoArrayCreationExpressionUnchecked x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PrimaryNoArrayCreationExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "unchecked"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

propertyBodyBlock :: Phantoms.TTerm Syntax.BlockPropertyBody -> Phantoms.TTerm Syntax.PropertyBody
propertyBodyBlock x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PropertyBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "block"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

propertyBodyExpression :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.PropertyBody
propertyBodyExpression x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PropertyBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "expression"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

propertyDeclarationRefReturn :: Phantoms.TTerm Syntax.RefReturnPropertyDeclaration -> Phantoms.TTerm Syntax.PropertyDeclaration
propertyDeclarationRefReturn x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PropertyDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "refReturn"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

propertyDeclarationStandard :: Phantoms.TTerm Syntax.StandardPropertyDeclaration -> Phantoms.TTerm Syntax.PropertyDeclaration
propertyDeclarationStandard x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PropertyDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "standard"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

propertyModifierAbstract :: Phantoms.TTerm Syntax.PropertyModifier
propertyModifierAbstract =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PropertyModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "abstract"),
        Core.fieldTerm = Core.TermUnit}}))

propertyModifierExtern :: Phantoms.TTerm Syntax.PropertyModifier
propertyModifierExtern =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PropertyModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "extern"),
        Core.fieldTerm = Core.TermUnit}}))

propertyModifierInternal :: Phantoms.TTerm Syntax.PropertyModifier
propertyModifierInternal =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PropertyModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "internal"),
        Core.fieldTerm = Core.TermUnit}}))

propertyModifierNew :: Phantoms.TTerm Syntax.PropertyModifier
propertyModifierNew =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PropertyModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "new"),
        Core.fieldTerm = Core.TermUnit}}))

propertyModifierOverride :: Phantoms.TTerm Syntax.PropertyModifier
propertyModifierOverride =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PropertyModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "override"),
        Core.fieldTerm = Core.TermUnit}}))

propertyModifierPrivate :: Phantoms.TTerm Syntax.PropertyModifier
propertyModifierPrivate =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PropertyModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "private"),
        Core.fieldTerm = Core.TermUnit}}))

propertyModifierProtected :: Phantoms.TTerm Syntax.PropertyModifier
propertyModifierProtected =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PropertyModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "protected"),
        Core.fieldTerm = Core.TermUnit}}))

propertyModifierPublic :: Phantoms.TTerm Syntax.PropertyModifier
propertyModifierPublic =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PropertyModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "public"),
        Core.fieldTerm = Core.TermUnit}}))

propertyModifierSealed :: Phantoms.TTerm Syntax.PropertyModifier
propertyModifierSealed =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PropertyModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "sealed"),
        Core.fieldTerm = Core.TermUnit}}))

propertyModifierStatic :: Phantoms.TTerm Syntax.PropertyModifier
propertyModifierStatic =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PropertyModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "static"),
        Core.fieldTerm = Core.TermUnit}}))

propertyModifierUnsafe :: Phantoms.TTerm Syntax.PropertyModifier
propertyModifierUnsafe =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PropertyModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "unsafe"),
        Core.fieldTerm = Core.TermUnit}}))

propertyModifierVirtual :: Phantoms.TTerm Syntax.PropertyModifier
propertyModifierVirtual =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.PropertyModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "virtual"),
        Core.fieldTerm = Core.TermUnit}}))

qualifiedAliasMember :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList) -> Phantoms.TTerm Syntax.QualifiedAliasMember
qualifiedAliasMember alias member arguments =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.QualifiedAliasMember"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "alias"),
          Core.fieldTerm = (Phantoms.unTTerm alias)},
        Core.Field {
          Core.fieldName = (Core.Name "member"),
          Core.fieldTerm = (Phantoms.unTTerm member)},
        Core.Field {
          Core.fieldName = (Core.Name "arguments"),
          Core.fieldTerm = (Phantoms.unTTerm arguments)}]}))

qualifiedAliasMemberAlias :: Phantoms.TTerm Syntax.QualifiedAliasMember -> Phantoms.TTerm Syntax.Identifier
qualifiedAliasMemberAlias x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QualifiedAliasMember"),
        Core.projectionField = (Core.Name "alias")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

qualifiedAliasMemberArguments :: Phantoms.TTerm Syntax.QualifiedAliasMember -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList)
qualifiedAliasMemberArguments x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QualifiedAliasMember"),
        Core.projectionField = (Core.Name "arguments")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

qualifiedAliasMemberMember :: Phantoms.TTerm Syntax.QualifiedAliasMember -> Phantoms.TTerm Syntax.Identifier
qualifiedAliasMemberMember x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QualifiedAliasMember"),
        Core.projectionField = (Core.Name "member")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

qualifiedAliasMemberWithAlias :: Phantoms.TTerm Syntax.QualifiedAliasMember -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.QualifiedAliasMember
qualifiedAliasMemberWithAlias original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.QualifiedAliasMember"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "alias"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "member"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QualifiedAliasMember"),
              Core.projectionField = (Core.Name "member")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "arguments"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QualifiedAliasMember"),
              Core.projectionField = (Core.Name "arguments")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

qualifiedAliasMemberWithArguments :: Phantoms.TTerm Syntax.QualifiedAliasMember -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList) -> Phantoms.TTerm Syntax.QualifiedAliasMember
qualifiedAliasMemberWithArguments original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.QualifiedAliasMember"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "alias"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QualifiedAliasMember"),
              Core.projectionField = (Core.Name "alias")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "member"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QualifiedAliasMember"),
              Core.projectionField = (Core.Name "member")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "arguments"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

qualifiedAliasMemberWithMember :: Phantoms.TTerm Syntax.QualifiedAliasMember -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.QualifiedAliasMember
qualifiedAliasMemberWithMember original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.QualifiedAliasMember"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "alias"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QualifiedAliasMember"),
              Core.projectionField = (Core.Name "alias")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "member"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "arguments"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QualifiedAliasMember"),
              Core.projectionField = (Core.Name "arguments")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

qualifiedIdentifier :: Phantoms.TTerm [Syntax.Identifier] -> Phantoms.TTerm Syntax.QualifiedIdentifier
qualifiedIdentifier x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.QualifiedIdentifier"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

qualifiedNamespaceOrTypeName :: Phantoms.TTerm Syntax.NamespaceOrTypeName -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList) -> Phantoms.TTerm Syntax.QualifiedNamespaceOrTypeName
qualifiedNamespaceOrTypeName namespaceOrType identifier arguments =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.QualifiedNamespaceOrTypeName"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "namespaceOrType"),
          Core.fieldTerm = (Phantoms.unTTerm namespaceOrType)},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm identifier)},
        Core.Field {
          Core.fieldName = (Core.Name "arguments"),
          Core.fieldTerm = (Phantoms.unTTerm arguments)}]}))

qualifiedNamespaceOrTypeNameArguments :: Phantoms.TTerm Syntax.QualifiedNamespaceOrTypeName -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList)
qualifiedNamespaceOrTypeNameArguments x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QualifiedNamespaceOrTypeName"),
        Core.projectionField = (Core.Name "arguments")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

qualifiedNamespaceOrTypeNameIdentifier :: Phantoms.TTerm Syntax.QualifiedNamespaceOrTypeName -> Phantoms.TTerm Syntax.Identifier
qualifiedNamespaceOrTypeNameIdentifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QualifiedNamespaceOrTypeName"),
        Core.projectionField = (Core.Name "identifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

qualifiedNamespaceOrTypeNameNamespaceOrType :: Phantoms.TTerm Syntax.QualifiedNamespaceOrTypeName -> Phantoms.TTerm Syntax.NamespaceOrTypeName
qualifiedNamespaceOrTypeNameNamespaceOrType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QualifiedNamespaceOrTypeName"),
        Core.projectionField = (Core.Name "namespaceOrType")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

qualifiedNamespaceOrTypeNameWithArguments :: Phantoms.TTerm Syntax.QualifiedNamespaceOrTypeName -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList) -> Phantoms.TTerm Syntax.QualifiedNamespaceOrTypeName
qualifiedNamespaceOrTypeNameWithArguments original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.QualifiedNamespaceOrTypeName"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "namespaceOrType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QualifiedNamespaceOrTypeName"),
              Core.projectionField = (Core.Name "namespaceOrType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QualifiedNamespaceOrTypeName"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "arguments"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

qualifiedNamespaceOrTypeNameWithIdentifier :: Phantoms.TTerm Syntax.QualifiedNamespaceOrTypeName -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.QualifiedNamespaceOrTypeName
qualifiedNamespaceOrTypeNameWithIdentifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.QualifiedNamespaceOrTypeName"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "namespaceOrType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QualifiedNamespaceOrTypeName"),
              Core.projectionField = (Core.Name "namespaceOrType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "arguments"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QualifiedNamespaceOrTypeName"),
              Core.projectionField = (Core.Name "arguments")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

qualifiedNamespaceOrTypeNameWithNamespaceOrType :: Phantoms.TTerm Syntax.QualifiedNamespaceOrTypeName -> Phantoms.TTerm Syntax.NamespaceOrTypeName -> Phantoms.TTerm Syntax.QualifiedNamespaceOrTypeName
qualifiedNamespaceOrTypeNameWithNamespaceOrType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.QualifiedNamespaceOrTypeName"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "namespaceOrType"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QualifiedNamespaceOrTypeName"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "arguments"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QualifiedNamespaceOrTypeName"),
              Core.projectionField = (Core.Name "arguments")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

queryBody :: Phantoms.TTerm [Syntax.QueryBodyClause] -> Phantoms.TTerm Syntax.SelectOrGroupClause -> Phantoms.TTerm (Maybe Syntax.QueryContinuation) -> Phantoms.TTerm Syntax.QueryBody
queryBody clauses selectOrGroup continuation =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.QueryBody"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "clauses"),
          Core.fieldTerm = (Phantoms.unTTerm clauses)},
        Core.Field {
          Core.fieldName = (Core.Name "selectOrGroup"),
          Core.fieldTerm = (Phantoms.unTTerm selectOrGroup)},
        Core.Field {
          Core.fieldName = (Core.Name "continuation"),
          Core.fieldTerm = (Phantoms.unTTerm continuation)}]}))

queryBodyClauseFrom :: Phantoms.TTerm Syntax.FromClause -> Phantoms.TTerm Syntax.QueryBodyClause
queryBodyClauseFrom x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.QueryBodyClause"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "from"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

queryBodyClauseJoin :: Phantoms.TTerm Syntax.JoinClause -> Phantoms.TTerm Syntax.QueryBodyClause
queryBodyClauseJoin x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.QueryBodyClause"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "join"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

queryBodyClauseLet :: Phantoms.TTerm Syntax.LetClause -> Phantoms.TTerm Syntax.QueryBodyClause
queryBodyClauseLet x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.QueryBodyClause"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "let"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

queryBodyClauseOrderby :: Phantoms.TTerm [Syntax.Ordering] -> Phantoms.TTerm Syntax.QueryBodyClause
queryBodyClauseOrderby x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.QueryBodyClause"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "orderby"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

queryBodyClauseWhere :: Phantoms.TTerm Syntax.BooleanExpression -> Phantoms.TTerm Syntax.QueryBodyClause
queryBodyClauseWhere x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.QueryBodyClause"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "where"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

queryBodyClauses :: Phantoms.TTerm Syntax.QueryBody -> Phantoms.TTerm [Syntax.QueryBodyClause]
queryBodyClauses x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QueryBody"),
        Core.projectionField = (Core.Name "clauses")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

queryBodyContinuation :: Phantoms.TTerm Syntax.QueryBody -> Phantoms.TTerm (Maybe Syntax.QueryContinuation)
queryBodyContinuation x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QueryBody"),
        Core.projectionField = (Core.Name "continuation")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

queryBodySelectOrGroup :: Phantoms.TTerm Syntax.QueryBody -> Phantoms.TTerm Syntax.SelectOrGroupClause
queryBodySelectOrGroup x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QueryBody"),
        Core.projectionField = (Core.Name "selectOrGroup")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

queryBodyWithClauses :: Phantoms.TTerm Syntax.QueryBody -> Phantoms.TTerm [Syntax.QueryBodyClause] -> Phantoms.TTerm Syntax.QueryBody
queryBodyWithClauses original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.QueryBody"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "clauses"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "selectOrGroup"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QueryBody"),
              Core.projectionField = (Core.Name "selectOrGroup")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "continuation"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QueryBody"),
              Core.projectionField = (Core.Name "continuation")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

queryBodyWithContinuation :: Phantoms.TTerm Syntax.QueryBody -> Phantoms.TTerm (Maybe Syntax.QueryContinuation) -> Phantoms.TTerm Syntax.QueryBody
queryBodyWithContinuation original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.QueryBody"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "clauses"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QueryBody"),
              Core.projectionField = (Core.Name "clauses")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "selectOrGroup"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QueryBody"),
              Core.projectionField = (Core.Name "selectOrGroup")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "continuation"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

queryBodyWithSelectOrGroup :: Phantoms.TTerm Syntax.QueryBody -> Phantoms.TTerm Syntax.SelectOrGroupClause -> Phantoms.TTerm Syntax.QueryBody
queryBodyWithSelectOrGroup original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.QueryBody"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "clauses"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QueryBody"),
              Core.projectionField = (Core.Name "clauses")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "selectOrGroup"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "continuation"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QueryBody"),
              Core.projectionField = (Core.Name "continuation")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

queryContinuation :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.QueryBody -> Phantoms.TTerm Syntax.QueryContinuation
queryContinuation into body =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.QueryContinuation"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "into"),
          Core.fieldTerm = (Phantoms.unTTerm into)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)}]}))

queryContinuationBody :: Phantoms.TTerm Syntax.QueryContinuation -> Phantoms.TTerm Syntax.QueryBody
queryContinuationBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QueryContinuation"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

queryContinuationInto :: Phantoms.TTerm Syntax.QueryContinuation -> Phantoms.TTerm Syntax.Identifier
queryContinuationInto x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QueryContinuation"),
        Core.projectionField = (Core.Name "into")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

queryContinuationWithBody :: Phantoms.TTerm Syntax.QueryContinuation -> Phantoms.TTerm Syntax.QueryBody -> Phantoms.TTerm Syntax.QueryContinuation
queryContinuationWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.QueryContinuation"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "into"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QueryContinuation"),
              Core.projectionField = (Core.Name "into")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

queryContinuationWithInto :: Phantoms.TTerm Syntax.QueryContinuation -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.QueryContinuation
queryContinuationWithInto original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.QueryContinuation"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "into"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QueryContinuation"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

queryExpression :: Phantoms.TTerm Syntax.FromClause -> Phantoms.TTerm Syntax.QueryBody -> Phantoms.TTerm Syntax.QueryExpression
queryExpression from body =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.QueryExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "from"),
          Core.fieldTerm = (Phantoms.unTTerm from)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)}]}))

queryExpressionBody :: Phantoms.TTerm Syntax.QueryExpression -> Phantoms.TTerm Syntax.QueryBody
queryExpressionBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QueryExpression"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

queryExpressionFrom :: Phantoms.TTerm Syntax.QueryExpression -> Phantoms.TTerm Syntax.FromClause
queryExpressionFrom x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QueryExpression"),
        Core.projectionField = (Core.Name "from")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

queryExpressionWithBody :: Phantoms.TTerm Syntax.QueryExpression -> Phantoms.TTerm Syntax.QueryBody -> Phantoms.TTerm Syntax.QueryExpression
queryExpressionWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.QueryExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "from"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QueryExpression"),
              Core.projectionField = (Core.Name "from")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

queryExpressionWithFrom :: Phantoms.TTerm Syntax.QueryExpression -> Phantoms.TTerm Syntax.FromClause -> Phantoms.TTerm Syntax.QueryExpression
queryExpressionWithFrom original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.QueryExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "from"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.QueryExpression"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

rankSpecifier :: Phantoms.TTerm Int -> Phantoms.TTerm Syntax.RankSpecifier
rankSpecifier x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.RankSpecifier"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

rankSpecifierArrayCreationExpression :: Phantoms.TTerm Syntax.RankSpecifier -> Phantoms.TTerm Syntax.ArrayInitializer -> Phantoms.TTerm Syntax.RankSpecifierArrayCreationExpression
rankSpecifierArrayCreationExpression rankSpecifier initializer =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RankSpecifierArrayCreationExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "rankSpecifier"),
          Core.fieldTerm = (Phantoms.unTTerm rankSpecifier)},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Phantoms.unTTerm initializer)}]}))

rankSpecifierArrayCreationExpressionInitializer :: Phantoms.TTerm Syntax.RankSpecifierArrayCreationExpression -> Phantoms.TTerm Syntax.ArrayInitializer
rankSpecifierArrayCreationExpressionInitializer x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RankSpecifierArrayCreationExpression"),
        Core.projectionField = (Core.Name "initializer")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

rankSpecifierArrayCreationExpressionRankSpecifier :: Phantoms.TTerm Syntax.RankSpecifierArrayCreationExpression -> Phantoms.TTerm Syntax.RankSpecifier
rankSpecifierArrayCreationExpressionRankSpecifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RankSpecifierArrayCreationExpression"),
        Core.projectionField = (Core.Name "rankSpecifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

rankSpecifierArrayCreationExpressionWithInitializer :: Phantoms.TTerm Syntax.RankSpecifierArrayCreationExpression -> Phantoms.TTerm Syntax.ArrayInitializer -> Phantoms.TTerm Syntax.RankSpecifierArrayCreationExpression
rankSpecifierArrayCreationExpressionWithInitializer original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RankSpecifierArrayCreationExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "rankSpecifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RankSpecifierArrayCreationExpression"),
              Core.projectionField = (Core.Name "rankSpecifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

rankSpecifierArrayCreationExpressionWithRankSpecifier :: Phantoms.TTerm Syntax.RankSpecifierArrayCreationExpression -> Phantoms.TTerm Syntax.RankSpecifier -> Phantoms.TTerm Syntax.RankSpecifierArrayCreationExpression
rankSpecifierArrayCreationExpressionWithRankSpecifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RankSpecifierArrayCreationExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "rankSpecifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RankSpecifierArrayCreationExpression"),
              Core.projectionField = (Core.Name "initializer")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

refAccessorBodyBlock :: Phantoms.TTerm Syntax.Block -> Phantoms.TTerm Syntax.RefAccessorBody
refAccessorBodyBlock x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RefAccessorBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "block"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

refAccessorBodyEmpty :: Phantoms.TTerm Syntax.RefAccessorBody
refAccessorBodyEmpty =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RefAccessorBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "empty"),
        Core.fieldTerm = Core.TermUnit}}))

refAccessorBodyRef :: Phantoms.TTerm Syntax.VariableReference -> Phantoms.TTerm Syntax.RefAccessorBody
refAccessorBodyRef x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RefAccessorBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "ref"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

refConditionalExpression :: Phantoms.TTerm Syntax.NullCoalescingExpression -> Phantoms.TTerm Syntax.VariableReference -> Phantoms.TTerm Syntax.VariableReference -> Phantoms.TTerm Syntax.RefConditionalExpression
refConditionalExpression condition true false =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefConditionalExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "condition"),
          Core.fieldTerm = (Phantoms.unTTerm condition)},
        Core.Field {
          Core.fieldName = (Core.Name "true"),
          Core.fieldTerm = (Phantoms.unTTerm true)},
        Core.Field {
          Core.fieldName = (Core.Name "false"),
          Core.fieldTerm = (Phantoms.unTTerm false)}]}))

refConditionalExpressionCondition :: Phantoms.TTerm Syntax.RefConditionalExpression -> Phantoms.TTerm Syntax.NullCoalescingExpression
refConditionalExpressionCondition x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefConditionalExpression"),
        Core.projectionField = (Core.Name "condition")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refConditionalExpressionFalse :: Phantoms.TTerm Syntax.RefConditionalExpression -> Phantoms.TTerm Syntax.VariableReference
refConditionalExpressionFalse x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefConditionalExpression"),
        Core.projectionField = (Core.Name "false")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refConditionalExpressionTrue :: Phantoms.TTerm Syntax.RefConditionalExpression -> Phantoms.TTerm Syntax.VariableReference
refConditionalExpressionTrue x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefConditionalExpression"),
        Core.projectionField = (Core.Name "true")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refConditionalExpressionWithCondition :: Phantoms.TTerm Syntax.RefConditionalExpression -> Phantoms.TTerm Syntax.NullCoalescingExpression -> Phantoms.TTerm Syntax.RefConditionalExpression
refConditionalExpressionWithCondition original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefConditionalExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "condition"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "true"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefConditionalExpression"),
              Core.projectionField = (Core.Name "true")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "false"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefConditionalExpression"),
              Core.projectionField = (Core.Name "false")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

refConditionalExpressionWithFalse :: Phantoms.TTerm Syntax.RefConditionalExpression -> Phantoms.TTerm Syntax.VariableReference -> Phantoms.TTerm Syntax.RefConditionalExpression
refConditionalExpressionWithFalse original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefConditionalExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "condition"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefConditionalExpression"),
              Core.projectionField = (Core.Name "condition")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "true"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefConditionalExpression"),
              Core.projectionField = (Core.Name "true")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "false"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

refConditionalExpressionWithTrue :: Phantoms.TTerm Syntax.RefConditionalExpression -> Phantoms.TTerm Syntax.VariableReference -> Phantoms.TTerm Syntax.RefConditionalExpression
refConditionalExpressionWithTrue original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefConditionalExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "condition"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefConditionalExpression"),
              Core.projectionField = (Core.Name "condition")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "true"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "false"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefConditionalExpression"),
              Core.projectionField = (Core.Name "false")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

refGetAccessorDeclaration :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm (Maybe Syntax.AccessorModifier) -> Phantoms.TTerm Syntax.RefAccessorBody -> Phantoms.TTerm Syntax.RefGetAccessorDeclaration
refGetAccessorDeclaration attributes modifier body =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefGetAccessorDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "modifier"),
          Core.fieldTerm = (Phantoms.unTTerm modifier)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)}]}))

refGetAccessorDeclarationAttributes :: Phantoms.TTerm Syntax.RefGetAccessorDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes)
refGetAccessorDeclarationAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefGetAccessorDeclaration"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refGetAccessorDeclarationBody :: Phantoms.TTerm Syntax.RefGetAccessorDeclaration -> Phantoms.TTerm Syntax.RefAccessorBody
refGetAccessorDeclarationBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefGetAccessorDeclaration"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refGetAccessorDeclarationModifier :: Phantoms.TTerm Syntax.RefGetAccessorDeclaration -> Phantoms.TTerm (Maybe Syntax.AccessorModifier)
refGetAccessorDeclarationModifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefGetAccessorDeclaration"),
        Core.projectionField = (Core.Name "modifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refGetAccessorDeclarationWithAttributes :: Phantoms.TTerm Syntax.RefGetAccessorDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.RefGetAccessorDeclaration
refGetAccessorDeclarationWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefGetAccessorDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "modifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefGetAccessorDeclaration"),
              Core.projectionField = (Core.Name "modifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefGetAccessorDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

refGetAccessorDeclarationWithBody :: Phantoms.TTerm Syntax.RefGetAccessorDeclaration -> Phantoms.TTerm Syntax.RefAccessorBody -> Phantoms.TTerm Syntax.RefGetAccessorDeclaration
refGetAccessorDeclarationWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefGetAccessorDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefGetAccessorDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefGetAccessorDeclaration"),
              Core.projectionField = (Core.Name "modifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

refGetAccessorDeclarationWithModifier :: Phantoms.TTerm Syntax.RefGetAccessorDeclaration -> Phantoms.TTerm (Maybe Syntax.AccessorModifier) -> Phantoms.TTerm Syntax.RefGetAccessorDeclaration
refGetAccessorDeclarationWithModifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefGetAccessorDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefGetAccessorDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefGetAccessorDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

refIndexerBodyBlock :: Phantoms.TTerm Syntax.RefGetAccessorDeclaration -> Phantoms.TTerm Syntax.RefIndexerBody
refIndexerBodyBlock x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "block"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

refIndexerBodyRef :: Phantoms.TTerm Syntax.VariableReference -> Phantoms.TTerm Syntax.RefIndexerBody
refIndexerBodyRef x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "ref"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

refIndexerDeclaration :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm [Syntax.IndexerModifier] -> Phantoms.TTerm Syntax.RefKind -> Phantoms.TTerm Syntax.IndexerDeclarator -> Phantoms.TTerm Syntax.RefIndexerBody -> Phantoms.TTerm Syntax.RefIndexerDeclaration
refIndexerDeclaration attributes modifiers refKind declarator body =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm modifiers)},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Phantoms.unTTerm refKind)},
        Core.Field {
          Core.fieldName = (Core.Name "declarator"),
          Core.fieldTerm = (Phantoms.unTTerm declarator)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)}]}))

refIndexerDeclarationAttributes :: Phantoms.TTerm Syntax.RefIndexerDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes)
refIndexerDeclarationAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerDeclaration"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refIndexerDeclarationBody :: Phantoms.TTerm Syntax.RefIndexerDeclaration -> Phantoms.TTerm Syntax.RefIndexerBody
refIndexerDeclarationBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerDeclaration"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refIndexerDeclarationDeclarator :: Phantoms.TTerm Syntax.RefIndexerDeclaration -> Phantoms.TTerm Syntax.IndexerDeclarator
refIndexerDeclarationDeclarator x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerDeclaration"),
        Core.projectionField = (Core.Name "declarator")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refIndexerDeclarationModifiers :: Phantoms.TTerm Syntax.RefIndexerDeclaration -> Phantoms.TTerm [Syntax.IndexerModifier]
refIndexerDeclarationModifiers x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerDeclaration"),
        Core.projectionField = (Core.Name "modifiers")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refIndexerDeclarationRefKind :: Phantoms.TTerm Syntax.RefIndexerDeclaration -> Phantoms.TTerm Syntax.RefKind
refIndexerDeclarationRefKind x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerDeclaration"),
        Core.projectionField = (Core.Name "refKind")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refIndexerDeclarationWithAttributes :: Phantoms.TTerm Syntax.RefIndexerDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.RefIndexerDeclaration
refIndexerDeclarationWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerDeclaration"),
              Core.projectionField = (Core.Name "declarator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

refIndexerDeclarationWithBody :: Phantoms.TTerm Syntax.RefIndexerDeclaration -> Phantoms.TTerm Syntax.RefIndexerBody -> Phantoms.TTerm Syntax.RefIndexerDeclaration
refIndexerDeclarationWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerDeclaration"),
              Core.projectionField = (Core.Name "declarator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

refIndexerDeclarationWithDeclarator :: Phantoms.TTerm Syntax.RefIndexerDeclaration -> Phantoms.TTerm Syntax.IndexerDeclarator -> Phantoms.TTerm Syntax.RefIndexerDeclaration
refIndexerDeclarationWithDeclarator original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarator"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

refIndexerDeclarationWithModifiers :: Phantoms.TTerm Syntax.RefIndexerDeclaration -> Phantoms.TTerm [Syntax.IndexerModifier] -> Phantoms.TTerm Syntax.RefIndexerDeclaration
refIndexerDeclarationWithModifiers original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerDeclaration"),
              Core.projectionField = (Core.Name "declarator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

refIndexerDeclarationWithRefKind :: Phantoms.TTerm Syntax.RefIndexerDeclaration -> Phantoms.TTerm Syntax.RefKind -> Phantoms.TTerm Syntax.RefIndexerDeclaration
refIndexerDeclarationWithRefKind original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "declarator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerDeclaration"),
              Core.projectionField = (Core.Name "declarator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefIndexerDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

refKindRef :: Phantoms.TTerm Syntax.RefKind
refKindRef =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RefKind"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "ref"),
        Core.fieldTerm = Core.TermUnit}}))

refKindRefReadonly :: Phantoms.TTerm Syntax.RefKind
refKindRefReadonly =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RefKind"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "refReadonly"),
        Core.fieldTerm = Core.TermUnit}}))

refLocalFunctionBodyBlock :: Phantoms.TTerm Syntax.Block -> Phantoms.TTerm Syntax.RefLocalFunctionBody
refLocalFunctionBodyBlock x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "block"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

refLocalFunctionBodyRef :: Phantoms.TTerm Syntax.VariableReference -> Phantoms.TTerm Syntax.RefLocalFunctionBody
refLocalFunctionBodyRef x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "ref"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

refLocalFunctionDeclaration :: Phantoms.TTerm [Syntax.RefLocalFunctionModifier] -> Phantoms.TTerm Syntax.RefKind -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.LocalFunctionHeader -> Phantoms.TTerm Syntax.RefLocalFunctionBody -> Phantoms.TTerm Syntax.RefLocalFunctionDeclaration
refLocalFunctionDeclaration modifiers refKind returnType header body =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm modifiers)},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Phantoms.unTTerm refKind)},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Phantoms.unTTerm returnType)},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Phantoms.unTTerm header)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)}]}))

refLocalFunctionDeclarationBody :: Phantoms.TTerm Syntax.RefLocalFunctionDeclaration -> Phantoms.TTerm Syntax.RefLocalFunctionBody
refLocalFunctionDeclarationBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refLocalFunctionDeclarationHeader :: Phantoms.TTerm Syntax.RefLocalFunctionDeclaration -> Phantoms.TTerm Syntax.LocalFunctionHeader
refLocalFunctionDeclarationHeader x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration"),
        Core.projectionField = (Core.Name "header")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refLocalFunctionDeclarationModifiers :: Phantoms.TTerm Syntax.RefLocalFunctionDeclaration -> Phantoms.TTerm [Syntax.RefLocalFunctionModifier]
refLocalFunctionDeclarationModifiers x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration"),
        Core.projectionField = (Core.Name "modifiers")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refLocalFunctionDeclarationRefKind :: Phantoms.TTerm Syntax.RefLocalFunctionDeclaration -> Phantoms.TTerm Syntax.RefKind
refLocalFunctionDeclarationRefKind x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration"),
        Core.projectionField = (Core.Name "refKind")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refLocalFunctionDeclarationReturnType :: Phantoms.TTerm Syntax.RefLocalFunctionDeclaration -> Phantoms.TTerm Syntax.Type
refLocalFunctionDeclarationReturnType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration"),
        Core.projectionField = (Core.Name "returnType")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refLocalFunctionDeclarationWithBody :: Phantoms.TTerm Syntax.RefLocalFunctionDeclaration -> Phantoms.TTerm Syntax.RefLocalFunctionBody -> Phantoms.TTerm Syntax.RefLocalFunctionDeclaration
refLocalFunctionDeclarationWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "returnType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "header")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

refLocalFunctionDeclarationWithHeader :: Phantoms.TTerm Syntax.RefLocalFunctionDeclaration -> Phantoms.TTerm Syntax.LocalFunctionHeader -> Phantoms.TTerm Syntax.RefLocalFunctionDeclaration
refLocalFunctionDeclarationWithHeader original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "returnType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

refLocalFunctionDeclarationWithModifiers :: Phantoms.TTerm Syntax.RefLocalFunctionDeclaration -> Phantoms.TTerm [Syntax.RefLocalFunctionModifier] -> Phantoms.TTerm Syntax.RefLocalFunctionDeclaration
refLocalFunctionDeclarationWithModifiers original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "returnType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "header")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

refLocalFunctionDeclarationWithRefKind :: Phantoms.TTerm Syntax.RefLocalFunctionDeclaration -> Phantoms.TTerm Syntax.RefKind -> Phantoms.TTerm Syntax.RefLocalFunctionDeclaration
refLocalFunctionDeclarationWithRefKind original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "returnType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "header")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

refLocalFunctionDeclarationWithReturnType :: Phantoms.TTerm Syntax.RefLocalFunctionDeclaration -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.RefLocalFunctionDeclaration
refLocalFunctionDeclarationWithReturnType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "header")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

refLocalFunctionModifierStatic :: Phantoms.TTerm Syntax.RefLocalFunctionModifier
refLocalFunctionModifierStatic =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "static"),
        Core.fieldTerm = Core.TermUnit}}))

refLocalFunctionModifierUnsafe :: Phantoms.TTerm Syntax.RefLocalFunctionModifier
refLocalFunctionModifierUnsafe =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalFunctionModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "unsafe"),
        Core.fieldTerm = Core.TermUnit}}))

refLocalVariableDeclaration :: Phantoms.TTerm Syntax.RefKind -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm [Syntax.RefLocalVariableDeclarator] -> Phantoms.TTerm Syntax.RefLocalVariableDeclaration
refLocalVariableDeclaration refKind type_ declarators =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefLocalVariableDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Phantoms.unTTerm refKind)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Phantoms.unTTerm declarators)}]}))

refLocalVariableDeclarationDeclarators :: Phantoms.TTerm Syntax.RefLocalVariableDeclaration -> Phantoms.TTerm [Syntax.RefLocalVariableDeclarator]
refLocalVariableDeclarationDeclarators x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalVariableDeclaration"),
        Core.projectionField = (Core.Name "declarators")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refLocalVariableDeclarationRefKind :: Phantoms.TTerm Syntax.RefLocalVariableDeclaration -> Phantoms.TTerm Syntax.RefKind
refLocalVariableDeclarationRefKind x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalVariableDeclaration"),
        Core.projectionField = (Core.Name "refKind")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refLocalVariableDeclarationType :: Phantoms.TTerm Syntax.RefLocalVariableDeclaration -> Phantoms.TTerm Syntax.Type
refLocalVariableDeclarationType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalVariableDeclaration"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refLocalVariableDeclarationWithDeclarators :: Phantoms.TTerm Syntax.RefLocalVariableDeclaration -> Phantoms.TTerm [Syntax.RefLocalVariableDeclarator] -> Phantoms.TTerm Syntax.RefLocalVariableDeclaration
refLocalVariableDeclarationWithDeclarators original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefLocalVariableDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalVariableDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalVariableDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

refLocalVariableDeclarationWithRefKind :: Phantoms.TTerm Syntax.RefLocalVariableDeclaration -> Phantoms.TTerm Syntax.RefKind -> Phantoms.TTerm Syntax.RefLocalVariableDeclaration
refLocalVariableDeclarationWithRefKind original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefLocalVariableDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalVariableDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalVariableDeclaration"),
              Core.projectionField = (Core.Name "declarators")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

refLocalVariableDeclarationWithType :: Phantoms.TTerm Syntax.RefLocalVariableDeclaration -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.RefLocalVariableDeclaration
refLocalVariableDeclarationWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefLocalVariableDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalVariableDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalVariableDeclaration"),
              Core.projectionField = (Core.Name "declarators")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

refLocalVariableDeclarator :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.VariableReference -> Phantoms.TTerm Syntax.RefLocalVariableDeclarator
refLocalVariableDeclarator left right =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefLocalVariableDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Phantoms.unTTerm left)},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Phantoms.unTTerm right)}]}))

refLocalVariableDeclaratorLeft :: Phantoms.TTerm Syntax.RefLocalVariableDeclarator -> Phantoms.TTerm Syntax.Identifier
refLocalVariableDeclaratorLeft x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalVariableDeclarator"),
        Core.projectionField = (Core.Name "left")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refLocalVariableDeclaratorRight :: Phantoms.TTerm Syntax.RefLocalVariableDeclarator -> Phantoms.TTerm Syntax.VariableReference
refLocalVariableDeclaratorRight x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalVariableDeclarator"),
        Core.projectionField = (Core.Name "right")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refLocalVariableDeclaratorWithLeft :: Phantoms.TTerm Syntax.RefLocalVariableDeclarator -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.RefLocalVariableDeclarator
refLocalVariableDeclaratorWithLeft original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefLocalVariableDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalVariableDeclarator"),
              Core.projectionField = (Core.Name "right")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

refLocalVariableDeclaratorWithRight :: Phantoms.TTerm Syntax.RefLocalVariableDeclarator -> Phantoms.TTerm Syntax.VariableReference -> Phantoms.TTerm Syntax.RefLocalVariableDeclarator
refLocalVariableDeclaratorWithRight original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefLocalVariableDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "left"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefLocalVariableDeclarator"),
              Core.projectionField = (Core.Name "left")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "right"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

refMethodBodyBlock :: Phantoms.TTerm Syntax.Block -> Phantoms.TTerm Syntax.RefMethodBody
refMethodBodyBlock x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RefMethodBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "block"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

refMethodBodyEmpty :: Phantoms.TTerm Syntax.RefMethodBody
refMethodBodyEmpty =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RefMethodBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "empty"),
        Core.fieldTerm = Core.TermUnit}}))

refMethodBodyRef :: Phantoms.TTerm Syntax.VariableReference -> Phantoms.TTerm Syntax.RefMethodBody
refMethodBodyRef x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RefMethodBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "ref"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

refMethodModifierAbstract :: Phantoms.TTerm Syntax.RefMethodModifier
refMethodModifierAbstract =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RefMethodModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "abstract"),
        Core.fieldTerm = Core.TermUnit}}))

refMethodModifierExtern :: Phantoms.TTerm Syntax.RefMethodModifier
refMethodModifierExtern =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RefMethodModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "extern"),
        Core.fieldTerm = Core.TermUnit}}))

refMethodModifierInternal :: Phantoms.TTerm Syntax.RefMethodModifier
refMethodModifierInternal =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RefMethodModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "internal"),
        Core.fieldTerm = Core.TermUnit}}))

refMethodModifierNew :: Phantoms.TTerm Syntax.RefMethodModifier
refMethodModifierNew =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RefMethodModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "new"),
        Core.fieldTerm = Core.TermUnit}}))

refMethodModifierOverride :: Phantoms.TTerm Syntax.RefMethodModifier
refMethodModifierOverride =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RefMethodModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "override"),
        Core.fieldTerm = Core.TermUnit}}))

refMethodModifierPrivate :: Phantoms.TTerm Syntax.RefMethodModifier
refMethodModifierPrivate =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RefMethodModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "private"),
        Core.fieldTerm = Core.TermUnit}}))

refMethodModifierProtected :: Phantoms.TTerm Syntax.RefMethodModifier
refMethodModifierProtected =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RefMethodModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "protected"),
        Core.fieldTerm = Core.TermUnit}}))

refMethodModifierPublic :: Phantoms.TTerm Syntax.RefMethodModifier
refMethodModifierPublic =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RefMethodModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "public"),
        Core.fieldTerm = Core.TermUnit}}))

refMethodModifierSealed :: Phantoms.TTerm Syntax.RefMethodModifier
refMethodModifierSealed =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RefMethodModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "sealed"),
        Core.fieldTerm = Core.TermUnit}}))

refMethodModifierStatic :: Phantoms.TTerm Syntax.RefMethodModifier
refMethodModifierStatic =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RefMethodModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "static"),
        Core.fieldTerm = Core.TermUnit}}))

refMethodModifierUnsafe :: Phantoms.TTerm Syntax.RefMethodModifier
refMethodModifierUnsafe =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RefMethodModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "unsafe"),
        Core.fieldTerm = Core.TermUnit}}))

refMethodModifierVirtual :: Phantoms.TTerm Syntax.RefMethodModifier
refMethodModifierVirtual =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RefMethodModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "virtual"),
        Core.fieldTerm = Core.TermUnit}}))

refPropertyBodyBlock :: Phantoms.TTerm Syntax.RefGetAccessorDeclaration -> Phantoms.TTerm Syntax.RefPropertyBody
refPropertyBodyBlock x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RefPropertyBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "block"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

refPropertyBodyRef :: Phantoms.TTerm Syntax.VariableReference -> Phantoms.TTerm Syntax.RefPropertyBody
refPropertyBodyRef x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RefPropertyBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "ref"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

refReturnMethodDeclaration :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm [Syntax.RefMethodModifier] -> Phantoms.TTerm Syntax.RefKind -> Phantoms.TTerm Syntax.ReturnType -> Phantoms.TTerm Syntax.MethodHeader -> Phantoms.TTerm Syntax.RefMethodBody -> Phantoms.TTerm Syntax.RefReturnMethodDeclaration
refReturnMethodDeclaration attributes modifiers kind returnType header body =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm modifiers)},
        Core.Field {
          Core.fieldName = (Core.Name "kind"),
          Core.fieldTerm = (Phantoms.unTTerm kind)},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Phantoms.unTTerm returnType)},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Phantoms.unTTerm header)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)}]}))

refReturnMethodDeclarationAttributes :: Phantoms.TTerm Syntax.RefReturnMethodDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes)
refReturnMethodDeclarationAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refReturnMethodDeclarationBody :: Phantoms.TTerm Syntax.RefReturnMethodDeclaration -> Phantoms.TTerm Syntax.RefMethodBody
refReturnMethodDeclarationBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refReturnMethodDeclarationHeader :: Phantoms.TTerm Syntax.RefReturnMethodDeclaration -> Phantoms.TTerm Syntax.MethodHeader
refReturnMethodDeclarationHeader x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
        Core.projectionField = (Core.Name "header")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refReturnMethodDeclarationKind :: Phantoms.TTerm Syntax.RefReturnMethodDeclaration -> Phantoms.TTerm Syntax.RefKind
refReturnMethodDeclarationKind x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
        Core.projectionField = (Core.Name "kind")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refReturnMethodDeclarationModifiers :: Phantoms.TTerm Syntax.RefReturnMethodDeclaration -> Phantoms.TTerm [Syntax.RefMethodModifier]
refReturnMethodDeclarationModifiers x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
        Core.projectionField = (Core.Name "modifiers")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refReturnMethodDeclarationReturnType :: Phantoms.TTerm Syntax.RefReturnMethodDeclaration -> Phantoms.TTerm Syntax.ReturnType
refReturnMethodDeclarationReturnType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
        Core.projectionField = (Core.Name "returnType")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refReturnMethodDeclarationWithAttributes :: Phantoms.TTerm Syntax.RefReturnMethodDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.RefReturnMethodDeclaration
refReturnMethodDeclarationWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "kind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
              Core.projectionField = (Core.Name "kind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
              Core.projectionField = (Core.Name "returnType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
              Core.projectionField = (Core.Name "header")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

refReturnMethodDeclarationWithBody :: Phantoms.TTerm Syntax.RefReturnMethodDeclaration -> Phantoms.TTerm Syntax.RefMethodBody -> Phantoms.TTerm Syntax.RefReturnMethodDeclaration
refReturnMethodDeclarationWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "kind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
              Core.projectionField = (Core.Name "kind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
              Core.projectionField = (Core.Name "returnType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
              Core.projectionField = (Core.Name "header")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

refReturnMethodDeclarationWithHeader :: Phantoms.TTerm Syntax.RefReturnMethodDeclaration -> Phantoms.TTerm Syntax.MethodHeader -> Phantoms.TTerm Syntax.RefReturnMethodDeclaration
refReturnMethodDeclarationWithHeader original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "kind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
              Core.projectionField = (Core.Name "kind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
              Core.projectionField = (Core.Name "returnType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

refReturnMethodDeclarationWithKind :: Phantoms.TTerm Syntax.RefReturnMethodDeclaration -> Phantoms.TTerm Syntax.RefKind -> Phantoms.TTerm Syntax.RefReturnMethodDeclaration
refReturnMethodDeclarationWithKind original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "kind"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
              Core.projectionField = (Core.Name "returnType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
              Core.projectionField = (Core.Name "header")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

refReturnMethodDeclarationWithModifiers :: Phantoms.TTerm Syntax.RefReturnMethodDeclaration -> Phantoms.TTerm [Syntax.RefMethodModifier] -> Phantoms.TTerm Syntax.RefReturnMethodDeclaration
refReturnMethodDeclarationWithModifiers original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "kind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
              Core.projectionField = (Core.Name "kind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
              Core.projectionField = (Core.Name "returnType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
              Core.projectionField = (Core.Name "header")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

refReturnMethodDeclarationWithReturnType :: Phantoms.TTerm Syntax.RefReturnMethodDeclaration -> Phantoms.TTerm Syntax.ReturnType -> Phantoms.TTerm Syntax.RefReturnMethodDeclaration
refReturnMethodDeclarationWithReturnType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "kind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
              Core.projectionField = (Core.Name "kind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
              Core.projectionField = (Core.Name "header")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnMethodDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

refReturnPropertyDeclaration :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm [Syntax.PropertyModifier] -> Phantoms.TTerm Syntax.RefKind -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.MemberName -> Phantoms.TTerm Syntax.RefPropertyBody -> Phantoms.TTerm Syntax.RefReturnPropertyDeclaration
refReturnPropertyDeclaration attributes modifiers refKind type_ name body =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm modifiers)},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Phantoms.unTTerm refKind)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm name)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)}]}))

refReturnPropertyDeclarationAttributes :: Phantoms.TTerm Syntax.RefReturnPropertyDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes)
refReturnPropertyDeclarationAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refReturnPropertyDeclarationBody :: Phantoms.TTerm Syntax.RefReturnPropertyDeclaration -> Phantoms.TTerm Syntax.RefPropertyBody
refReturnPropertyDeclarationBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refReturnPropertyDeclarationModifiers :: Phantoms.TTerm Syntax.RefReturnPropertyDeclaration -> Phantoms.TTerm [Syntax.PropertyModifier]
refReturnPropertyDeclarationModifiers x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
        Core.projectionField = (Core.Name "modifiers")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refReturnPropertyDeclarationName :: Phantoms.TTerm Syntax.RefReturnPropertyDeclaration -> Phantoms.TTerm Syntax.MemberName
refReturnPropertyDeclarationName x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
        Core.projectionField = (Core.Name "name")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refReturnPropertyDeclarationRefKind :: Phantoms.TTerm Syntax.RefReturnPropertyDeclaration -> Phantoms.TTerm Syntax.RefKind
refReturnPropertyDeclarationRefKind x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
        Core.projectionField = (Core.Name "refKind")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refReturnPropertyDeclarationType :: Phantoms.TTerm Syntax.RefReturnPropertyDeclaration -> Phantoms.TTerm Syntax.Type
refReturnPropertyDeclarationType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refReturnPropertyDeclarationWithAttributes :: Phantoms.TTerm Syntax.RefReturnPropertyDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.RefReturnPropertyDeclaration
refReturnPropertyDeclarationWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

refReturnPropertyDeclarationWithBody :: Phantoms.TTerm Syntax.RefReturnPropertyDeclaration -> Phantoms.TTerm Syntax.RefPropertyBody -> Phantoms.TTerm Syntax.RefReturnPropertyDeclaration
refReturnPropertyDeclarationWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

refReturnPropertyDeclarationWithModifiers :: Phantoms.TTerm Syntax.RefReturnPropertyDeclaration -> Phantoms.TTerm [Syntax.PropertyModifier] -> Phantoms.TTerm Syntax.RefReturnPropertyDeclaration
refReturnPropertyDeclarationWithModifiers original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

refReturnPropertyDeclarationWithName :: Phantoms.TTerm Syntax.RefReturnPropertyDeclaration -> Phantoms.TTerm Syntax.MemberName -> Phantoms.TTerm Syntax.RefReturnPropertyDeclaration
refReturnPropertyDeclarationWithName original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

refReturnPropertyDeclarationWithRefKind :: Phantoms.TTerm Syntax.RefReturnPropertyDeclaration -> Phantoms.TTerm Syntax.RefKind -> Phantoms.TTerm Syntax.RefReturnPropertyDeclaration
refReturnPropertyDeclarationWithRefKind original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

refReturnPropertyDeclarationWithType :: Phantoms.TTerm Syntax.RefReturnPropertyDeclaration -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.RefReturnPropertyDeclaration
refReturnPropertyDeclarationWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefReturnPropertyDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

refVarImplicitlyTypedLocalVariableDeclaration :: Phantoms.TTerm Syntax.RefKind -> Phantoms.TTerm Syntax.RefLocalVariableDeclarator -> Phantoms.TTerm Syntax.RefVarImplicitlyTypedLocalVariableDeclaration
refVarImplicitlyTypedLocalVariableDeclaration refKind declarator =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Phantoms.unTTerm refKind)},
        Core.Field {
          Core.fieldName = (Core.Name "declarator"),
          Core.fieldTerm = (Phantoms.unTTerm declarator)}]}))

refVarImplicitlyTypedLocalVariableDeclarationDeclarator :: Phantoms.TTerm Syntax.RefVarImplicitlyTypedLocalVariableDeclaration -> Phantoms.TTerm Syntax.RefLocalVariableDeclarator
refVarImplicitlyTypedLocalVariableDeclarationDeclarator x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration"),
        Core.projectionField = (Core.Name "declarator")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refVarImplicitlyTypedLocalVariableDeclarationRefKind :: Phantoms.TTerm Syntax.RefVarImplicitlyTypedLocalVariableDeclaration -> Phantoms.TTerm Syntax.RefKind
refVarImplicitlyTypedLocalVariableDeclarationRefKind x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration"),
        Core.projectionField = (Core.Name "refKind")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

refVarImplicitlyTypedLocalVariableDeclarationWithDeclarator :: Phantoms.TTerm Syntax.RefVarImplicitlyTypedLocalVariableDeclaration -> Phantoms.TTerm Syntax.RefLocalVariableDeclarator -> Phantoms.TTerm Syntax.RefVarImplicitlyTypedLocalVariableDeclaration
refVarImplicitlyTypedLocalVariableDeclarationWithDeclarator original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration"),
              Core.projectionField = (Core.Name "refKind")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarator"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

refVarImplicitlyTypedLocalVariableDeclarationWithRefKind :: Phantoms.TTerm Syntax.RefVarImplicitlyTypedLocalVariableDeclaration -> Phantoms.TTerm Syntax.RefKind -> Phantoms.TTerm Syntax.RefVarImplicitlyTypedLocalVariableDeclaration
refVarImplicitlyTypedLocalVariableDeclarationWithRefKind original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "refKind"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "declarator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RefVarImplicitlyTypedLocalVariableDeclaration"),
              Core.projectionField = (Core.Name "declarator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

referenceTypeArray :: Phantoms.TTerm Syntax.ArrayType -> Phantoms.TTerm Syntax.ReferenceType
referenceTypeArray x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ReferenceType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "array"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

referenceTypeClass :: Phantoms.TTerm Syntax.ClassType -> Phantoms.TTerm Syntax.ReferenceType
referenceTypeClass x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ReferenceType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "class"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

referenceTypeDelegate :: Phantoms.TTerm Syntax.DelegateType -> Phantoms.TTerm Syntax.ReferenceType
referenceTypeDelegate x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ReferenceType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "delegate"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

referenceTypeDynamic :: Phantoms.TTerm Syntax.ReferenceType
referenceTypeDynamic =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ReferenceType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "dynamic"),
        Core.fieldTerm = Core.TermUnit}}))

referenceTypeInterface :: Phantoms.TTerm Syntax.InterfaceType -> Phantoms.TTerm Syntax.ReferenceType
referenceTypeInterface x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ReferenceType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "interface"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

regularInterpolation :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm (Maybe Syntax.Expression) -> Phantoms.TTerm (Maybe String) -> Phantoms.TTerm Syntax.RegularInterpolation
regularInterpolation expression width format =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RegularInterpolation"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm expression)},
        Core.Field {
          Core.fieldName = (Core.Name "width"),
          Core.fieldTerm = (Phantoms.unTTerm width)},
        Core.Field {
          Core.fieldName = (Core.Name "format"),
          Core.fieldTerm = (Phantoms.unTTerm format)}]}))

regularInterpolationExpression :: Phantoms.TTerm Syntax.RegularInterpolation -> Phantoms.TTerm Syntax.Expression
regularInterpolationExpression x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RegularInterpolation"),
        Core.projectionField = (Core.Name "expression")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

regularInterpolationFormat :: Phantoms.TTerm Syntax.RegularInterpolation -> Phantoms.TTerm (Maybe String)
regularInterpolationFormat x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RegularInterpolation"),
        Core.projectionField = (Core.Name "format")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

regularInterpolationWidth :: Phantoms.TTerm Syntax.RegularInterpolation -> Phantoms.TTerm (Maybe Syntax.Expression)
regularInterpolationWidth x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RegularInterpolation"),
        Core.projectionField = (Core.Name "width")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

regularInterpolationWithExpression :: Phantoms.TTerm Syntax.RegularInterpolation -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.RegularInterpolation
regularInterpolationWithExpression original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RegularInterpolation"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "width"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RegularInterpolation"),
              Core.projectionField = (Core.Name "width")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "format"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RegularInterpolation"),
              Core.projectionField = (Core.Name "format")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

regularInterpolationWithFormat :: Phantoms.TTerm Syntax.RegularInterpolation -> Phantoms.TTerm (Maybe String) -> Phantoms.TTerm Syntax.RegularInterpolation
regularInterpolationWithFormat original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RegularInterpolation"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RegularInterpolation"),
              Core.projectionField = (Core.Name "expression")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "width"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RegularInterpolation"),
              Core.projectionField = (Core.Name "width")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "format"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

regularInterpolationWithWidth :: Phantoms.TTerm Syntax.RegularInterpolation -> Phantoms.TTerm (Maybe Syntax.Expression) -> Phantoms.TTerm Syntax.RegularInterpolation
regularInterpolationWithWidth original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.RegularInterpolation"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RegularInterpolation"),
              Core.projectionField = (Core.Name "expression")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "width"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "format"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.RegularInterpolation"),
              Core.projectionField = (Core.Name "format")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

relationalExpressionAsType :: Phantoms.TTerm Syntax.AsTypeExpression -> Phantoms.TTerm Syntax.RelationalExpression
relationalExpressionAsType x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RelationalExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "asType"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

relationalExpressionBinary :: Phantoms.TTerm Syntax.BinaryRelationalExpression -> Phantoms.TTerm Syntax.RelationalExpression
relationalExpressionBinary x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RelationalExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "binary"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

relationalExpressionIsPattern :: Phantoms.TTerm Syntax.IsPatternExpression -> Phantoms.TTerm Syntax.RelationalExpression
relationalExpressionIsPattern x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RelationalExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "isPattern"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

relationalExpressionIsType :: Phantoms.TTerm Syntax.IsTypeExpression -> Phantoms.TTerm Syntax.RelationalExpression
relationalExpressionIsType x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RelationalExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "isType"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

relationalExpressionSimple :: Phantoms.TTerm Syntax.ShiftExpression -> Phantoms.TTerm Syntax.RelationalExpression
relationalExpressionSimple x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RelationalExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "simple"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

relationalOperatorGreaterThan :: Phantoms.TTerm Syntax.RelationalOperator
relationalOperatorGreaterThan =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RelationalOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "greaterThan"),
        Core.fieldTerm = Core.TermUnit}}))

relationalOperatorGreaterThanOrEqual :: Phantoms.TTerm Syntax.RelationalOperator
relationalOperatorGreaterThanOrEqual =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RelationalOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "greaterThanOrEqual"),
        Core.fieldTerm = Core.TermUnit}}))

relationalOperatorLessThan :: Phantoms.TTerm Syntax.RelationalOperator
relationalOperatorLessThan =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RelationalOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "lessThan"),
        Core.fieldTerm = Core.TermUnit}}))

relationalOperatorLessThanOrEqual :: Phantoms.TTerm Syntax.RelationalOperator
relationalOperatorLessThanOrEqual =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.RelationalOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "lessThanOrEqual"),
        Core.fieldTerm = Core.TermUnit}}))

resourceAcquisitionExpression :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.ResourceAcquisition
resourceAcquisitionExpression x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ResourceAcquisition"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "expression"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

resourceAcquisitionLocal :: Phantoms.TTerm Syntax.LocalVariableDeclaration -> Phantoms.TTerm Syntax.ResourceAcquisition
resourceAcquisitionLocal x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ResourceAcquisition"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "local"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

returnStatementRef :: Phantoms.TTerm Syntax.VariableReference -> Phantoms.TTerm Syntax.ReturnStatement
returnStatementRef x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ReturnStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "ref"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

returnStatementSimple :: Phantoms.TTerm Syntax.ReturnStatement
returnStatementSimple =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ReturnStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "simple"),
        Core.fieldTerm = Core.TermUnit}}))

returnStatementValue :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.ReturnStatement
returnStatementValue x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ReturnStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "value"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

returnTypeRef :: Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.ReturnType
returnTypeRef x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ReturnType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "ref"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

returnTypeVoid :: Phantoms.TTerm Syntax.ReturnType
returnTypeVoid =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ReturnType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "void"),
        Core.fieldTerm = Core.TermUnit}}))

secondaryConstraintInterface :: Phantoms.TTerm Syntax.InterfaceType -> Phantoms.TTerm Syntax.SecondaryConstraint
secondaryConstraintInterface x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.SecondaryConstraint"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "interface"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

secondaryConstraintParameter :: Phantoms.TTerm Syntax.TypeParameter -> Phantoms.TTerm Syntax.SecondaryConstraint
secondaryConstraintParameter x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.SecondaryConstraint"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "parameter"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

secondaryConstraints :: Phantoms.TTerm [Syntax.SecondaryConstraint] -> Phantoms.TTerm Syntax.SecondaryConstraints
secondaryConstraints x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.SecondaryConstraints"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

selectOrGroupClauseGroup :: Phantoms.TTerm Syntax.GroupClause -> Phantoms.TTerm Syntax.SelectOrGroupClause
selectOrGroupClauseGroup x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.SelectOrGroupClause"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "group"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

selectOrGroupClauseSelect :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.SelectOrGroupClause
selectOrGroupClauseSelect x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.SelectOrGroupClause"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "select"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

selectionStatementIf :: Phantoms.TTerm Syntax.IfStatement -> Phantoms.TTerm Syntax.SelectionStatement
selectionStatementIf x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.SelectionStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "if"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

selectionStatementSwitch :: Phantoms.TTerm Syntax.SwitchStatement -> Phantoms.TTerm Syntax.SelectionStatement
selectionStatementSwitch x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.SelectionStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "switch"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

shiftExpressionBinary :: Phantoms.TTerm Syntax.BinaryShiftExpression -> Phantoms.TTerm Syntax.ShiftExpression
shiftExpressionBinary x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ShiftExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "binary"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

shiftExpressionSimple :: Phantoms.TTerm Syntax.AdditiveExpression -> Phantoms.TTerm Syntax.ShiftExpression
shiftExpressionSimple x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ShiftExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "simple"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

shiftOperatorLeft :: Phantoms.TTerm Syntax.ShiftOperator
shiftOperatorLeft =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ShiftOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "left"),
        Core.fieldTerm = Core.TermUnit}}))

shiftOperatorRight :: Phantoms.TTerm Syntax.ShiftOperator
shiftOperatorRight =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ShiftOperator"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "right"),
        Core.fieldTerm = Core.TermUnit}}))

simpleConditionalExpression :: Phantoms.TTerm Syntax.NullCoalescingExpression -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.SimpleConditionalExpression
simpleConditionalExpression condition true false =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.SimpleConditionalExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "condition"),
          Core.fieldTerm = (Phantoms.unTTerm condition)},
        Core.Field {
          Core.fieldName = (Core.Name "true"),
          Core.fieldTerm = (Phantoms.unTTerm true)},
        Core.Field {
          Core.fieldName = (Core.Name "false"),
          Core.fieldTerm = (Phantoms.unTTerm false)}]}))

simpleConditionalExpressionCondition :: Phantoms.TTerm Syntax.SimpleConditionalExpression -> Phantoms.TTerm Syntax.NullCoalescingExpression
simpleConditionalExpressionCondition x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SimpleConditionalExpression"),
        Core.projectionField = (Core.Name "condition")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

simpleConditionalExpressionFalse :: Phantoms.TTerm Syntax.SimpleConditionalExpression -> Phantoms.TTerm Syntax.Expression
simpleConditionalExpressionFalse x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SimpleConditionalExpression"),
        Core.projectionField = (Core.Name "false")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

simpleConditionalExpressionTrue :: Phantoms.TTerm Syntax.SimpleConditionalExpression -> Phantoms.TTerm Syntax.Expression
simpleConditionalExpressionTrue x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SimpleConditionalExpression"),
        Core.projectionField = (Core.Name "true")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

simpleConditionalExpressionWithCondition :: Phantoms.TTerm Syntax.SimpleConditionalExpression -> Phantoms.TTerm Syntax.NullCoalescingExpression -> Phantoms.TTerm Syntax.SimpleConditionalExpression
simpleConditionalExpressionWithCondition original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.SimpleConditionalExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "condition"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "true"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SimpleConditionalExpression"),
              Core.projectionField = (Core.Name "true")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "false"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SimpleConditionalExpression"),
              Core.projectionField = (Core.Name "false")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

simpleConditionalExpressionWithFalse :: Phantoms.TTerm Syntax.SimpleConditionalExpression -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.SimpleConditionalExpression
simpleConditionalExpressionWithFalse original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.SimpleConditionalExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "condition"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SimpleConditionalExpression"),
              Core.projectionField = (Core.Name "condition")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "true"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SimpleConditionalExpression"),
              Core.projectionField = (Core.Name "true")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "false"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

simpleConditionalExpressionWithTrue :: Phantoms.TTerm Syntax.SimpleConditionalExpression -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.SimpleConditionalExpression
simpleConditionalExpressionWithTrue original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.SimpleConditionalExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "condition"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SimpleConditionalExpression"),
              Core.projectionField = (Core.Name "condition")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "true"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "false"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SimpleConditionalExpression"),
              Core.projectionField = (Core.Name "false")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

simpleName :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList) -> Phantoms.TTerm Syntax.SimpleName
simpleName identifier typeArguments =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.SimpleName"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm identifier)},
        Core.Field {
          Core.fieldName = (Core.Name "typeArguments"),
          Core.fieldTerm = (Phantoms.unTTerm typeArguments)}]}))

simpleNameIdentifier :: Phantoms.TTerm Syntax.SimpleName -> Phantoms.TTerm Syntax.Identifier
simpleNameIdentifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SimpleName"),
        Core.projectionField = (Core.Name "identifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

simpleNameTypeArguments :: Phantoms.TTerm Syntax.SimpleName -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList)
simpleNameTypeArguments x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SimpleName"),
        Core.projectionField = (Core.Name "typeArguments")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

simpleNameWithIdentifier :: Phantoms.TTerm Syntax.SimpleName -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.SimpleName
simpleNameWithIdentifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.SimpleName"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "typeArguments"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SimpleName"),
              Core.projectionField = (Core.Name "typeArguments")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

simpleNameWithTypeArguments :: Phantoms.TTerm Syntax.SimpleName -> Phantoms.TTerm (Maybe Syntax.TypeArgumentList) -> Phantoms.TTerm Syntax.SimpleName
simpleNameWithTypeArguments original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.SimpleName"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SimpleName"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "typeArguments"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

simpleTypeBool :: Phantoms.TTerm Syntax.SimpleType
simpleTypeBool =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.SimpleType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "bool"),
        Core.fieldTerm = Core.TermUnit}}))

simpleTypeNumeric :: Phantoms.TTerm Syntax.NumericType -> Phantoms.TTerm Syntax.SimpleType
simpleTypeNumeric x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.SimpleType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "numeric"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

specificCatchClause :: Phantoms.TTerm (Maybe Syntax.ExceptionSpecifier) -> Phantoms.TTerm (Maybe Syntax.BooleanExpression) -> Phantoms.TTerm Syntax.Block -> Phantoms.TTerm Syntax.SpecificCatchClause
specificCatchClause specifier filter body =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.SpecificCatchClause"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "specifier"),
          Core.fieldTerm = (Phantoms.unTTerm specifier)},
        Core.Field {
          Core.fieldName = (Core.Name "filter"),
          Core.fieldTerm = (Phantoms.unTTerm filter)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)}]}))

specificCatchClauseBody :: Phantoms.TTerm Syntax.SpecificCatchClause -> Phantoms.TTerm Syntax.Block
specificCatchClauseBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SpecificCatchClause"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

specificCatchClauseFilter :: Phantoms.TTerm Syntax.SpecificCatchClause -> Phantoms.TTerm (Maybe Syntax.BooleanExpression)
specificCatchClauseFilter x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SpecificCatchClause"),
        Core.projectionField = (Core.Name "filter")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

specificCatchClauseSpecifier :: Phantoms.TTerm Syntax.SpecificCatchClause -> Phantoms.TTerm (Maybe Syntax.ExceptionSpecifier)
specificCatchClauseSpecifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SpecificCatchClause"),
        Core.projectionField = (Core.Name "specifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

specificCatchClauseWithBody :: Phantoms.TTerm Syntax.SpecificCatchClause -> Phantoms.TTerm Syntax.Block -> Phantoms.TTerm Syntax.SpecificCatchClause
specificCatchClauseWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.SpecificCatchClause"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "specifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SpecificCatchClause"),
              Core.projectionField = (Core.Name "specifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "filter"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SpecificCatchClause"),
              Core.projectionField = (Core.Name "filter")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

specificCatchClauseWithFilter :: Phantoms.TTerm Syntax.SpecificCatchClause -> Phantoms.TTerm (Maybe Syntax.BooleanExpression) -> Phantoms.TTerm Syntax.SpecificCatchClause
specificCatchClauseWithFilter original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.SpecificCatchClause"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "specifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SpecificCatchClause"),
              Core.projectionField = (Core.Name "specifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "filter"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SpecificCatchClause"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

specificCatchClauseWithSpecifier :: Phantoms.TTerm Syntax.SpecificCatchClause -> Phantoms.TTerm (Maybe Syntax.ExceptionSpecifier) -> Phantoms.TTerm Syntax.SpecificCatchClause
specificCatchClauseWithSpecifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.SpecificCatchClause"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "specifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "filter"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SpecificCatchClause"),
              Core.projectionField = (Core.Name "filter")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SpecificCatchClause"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

stackallocExpression :: Phantoms.TTerm (Maybe Syntax.UnmanagedType) -> Phantoms.TTerm (Maybe Syntax.ConstantExpression) -> Phantoms.TTerm [Syntax.Expression] -> Phantoms.TTerm Syntax.StackallocExpression
stackallocExpression type_ expression initializer =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StackallocExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm expression)},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Phantoms.unTTerm initializer)}]}))

stackallocExpressionExpression :: Phantoms.TTerm Syntax.StackallocExpression -> Phantoms.TTerm (Maybe Syntax.ConstantExpression)
stackallocExpressionExpression x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StackallocExpression"),
        Core.projectionField = (Core.Name "expression")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

stackallocExpressionInitializer :: Phantoms.TTerm Syntax.StackallocExpression -> Phantoms.TTerm [Syntax.Expression]
stackallocExpressionInitializer x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StackallocExpression"),
        Core.projectionField = (Core.Name "initializer")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

stackallocExpressionType :: Phantoms.TTerm Syntax.StackallocExpression -> Phantoms.TTerm (Maybe Syntax.UnmanagedType)
stackallocExpressionType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StackallocExpression"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

stackallocExpressionWithExpression :: Phantoms.TTerm Syntax.StackallocExpression -> Phantoms.TTerm (Maybe Syntax.ConstantExpression) -> Phantoms.TTerm Syntax.StackallocExpression
stackallocExpressionWithExpression original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StackallocExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StackallocExpression"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StackallocExpression"),
              Core.projectionField = (Core.Name "initializer")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

stackallocExpressionWithInitializer :: Phantoms.TTerm Syntax.StackallocExpression -> Phantoms.TTerm [Syntax.Expression] -> Phantoms.TTerm Syntax.StackallocExpression
stackallocExpressionWithInitializer original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StackallocExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StackallocExpression"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StackallocExpression"),
              Core.projectionField = (Core.Name "expression")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

stackallocExpressionWithType :: Phantoms.TTerm Syntax.StackallocExpression -> Phantoms.TTerm (Maybe Syntax.UnmanagedType) -> Phantoms.TTerm Syntax.StackallocExpression
stackallocExpressionWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StackallocExpression"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StackallocExpression"),
              Core.projectionField = (Core.Name "expression")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StackallocExpression"),
              Core.projectionField = (Core.Name "initializer")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

standardEventDeclaration :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm [Syntax.EventModifier] -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.VariableDeclarators -> Phantoms.TTerm Syntax.StandardEventDeclaration
standardEventDeclaration attributes modifiers type_ declarators =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StandardEventDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm modifiers)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Phantoms.unTTerm declarators)}]}))

standardEventDeclarationAttributes :: Phantoms.TTerm Syntax.StandardEventDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes)
standardEventDeclarationAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardEventDeclaration"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

standardEventDeclarationDeclarators :: Phantoms.TTerm Syntax.StandardEventDeclaration -> Phantoms.TTerm Syntax.VariableDeclarators
standardEventDeclarationDeclarators x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardEventDeclaration"),
        Core.projectionField = (Core.Name "declarators")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

standardEventDeclarationModifiers :: Phantoms.TTerm Syntax.StandardEventDeclaration -> Phantoms.TTerm [Syntax.EventModifier]
standardEventDeclarationModifiers x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardEventDeclaration"),
        Core.projectionField = (Core.Name "modifiers")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

standardEventDeclarationType :: Phantoms.TTerm Syntax.StandardEventDeclaration -> Phantoms.TTerm Syntax.Type
standardEventDeclarationType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardEventDeclaration"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

standardEventDeclarationWithAttributes :: Phantoms.TTerm Syntax.StandardEventDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.StandardEventDeclaration
standardEventDeclarationWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StandardEventDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardEventDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardEventDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardEventDeclaration"),
              Core.projectionField = (Core.Name "declarators")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

standardEventDeclarationWithDeclarators :: Phantoms.TTerm Syntax.StandardEventDeclaration -> Phantoms.TTerm Syntax.VariableDeclarators -> Phantoms.TTerm Syntax.StandardEventDeclaration
standardEventDeclarationWithDeclarators original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StandardEventDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardEventDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardEventDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardEventDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

standardEventDeclarationWithModifiers :: Phantoms.TTerm Syntax.StandardEventDeclaration -> Phantoms.TTerm [Syntax.EventModifier] -> Phantoms.TTerm Syntax.StandardEventDeclaration
standardEventDeclarationWithModifiers original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StandardEventDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardEventDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardEventDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardEventDeclaration"),
              Core.projectionField = (Core.Name "declarators")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

standardEventDeclarationWithType :: Phantoms.TTerm Syntax.StandardEventDeclaration -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.StandardEventDeclaration
standardEventDeclarationWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StandardEventDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardEventDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardEventDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "declarators"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardEventDeclaration"),
              Core.projectionField = (Core.Name "declarators")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

standardIndexerDeclaration :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm [Syntax.IndexerModifier] -> Phantoms.TTerm Syntax.IndexerDeclarator -> Phantoms.TTerm Syntax.IndexerBody -> Phantoms.TTerm Syntax.StandardIndexerDeclaration
standardIndexerDeclaration attributes modifiers declarator body =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StandardIndexerDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm modifiers)},
        Core.Field {
          Core.fieldName = (Core.Name "declarator"),
          Core.fieldTerm = (Phantoms.unTTerm declarator)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)}]}))

standardIndexerDeclarationAttributes :: Phantoms.TTerm Syntax.StandardIndexerDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes)
standardIndexerDeclarationAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardIndexerDeclaration"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

standardIndexerDeclarationBody :: Phantoms.TTerm Syntax.StandardIndexerDeclaration -> Phantoms.TTerm Syntax.IndexerBody
standardIndexerDeclarationBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardIndexerDeclaration"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

standardIndexerDeclarationDeclarator :: Phantoms.TTerm Syntax.StandardIndexerDeclaration -> Phantoms.TTerm Syntax.IndexerDeclarator
standardIndexerDeclarationDeclarator x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardIndexerDeclaration"),
        Core.projectionField = (Core.Name "declarator")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

standardIndexerDeclarationModifiers :: Phantoms.TTerm Syntax.StandardIndexerDeclaration -> Phantoms.TTerm [Syntax.IndexerModifier]
standardIndexerDeclarationModifiers x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardIndexerDeclaration"),
        Core.projectionField = (Core.Name "modifiers")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

standardIndexerDeclarationWithAttributes :: Phantoms.TTerm Syntax.StandardIndexerDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.StandardIndexerDeclaration
standardIndexerDeclarationWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StandardIndexerDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardIndexerDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardIndexerDeclaration"),
              Core.projectionField = (Core.Name "declarator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardIndexerDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

standardIndexerDeclarationWithBody :: Phantoms.TTerm Syntax.StandardIndexerDeclaration -> Phantoms.TTerm Syntax.IndexerBody -> Phantoms.TTerm Syntax.StandardIndexerDeclaration
standardIndexerDeclarationWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StandardIndexerDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardIndexerDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardIndexerDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardIndexerDeclaration"),
              Core.projectionField = (Core.Name "declarator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

standardIndexerDeclarationWithDeclarator :: Phantoms.TTerm Syntax.StandardIndexerDeclaration -> Phantoms.TTerm Syntax.IndexerDeclarator -> Phantoms.TTerm Syntax.StandardIndexerDeclaration
standardIndexerDeclarationWithDeclarator original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StandardIndexerDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardIndexerDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardIndexerDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "declarator"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardIndexerDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

standardIndexerDeclarationWithModifiers :: Phantoms.TTerm Syntax.StandardIndexerDeclaration -> Phantoms.TTerm [Syntax.IndexerModifier] -> Phantoms.TTerm Syntax.StandardIndexerDeclaration
standardIndexerDeclarationWithModifiers original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StandardIndexerDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardIndexerDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "declarator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardIndexerDeclaration"),
              Core.projectionField = (Core.Name "declarator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardIndexerDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

standardLocalFunctionDeclaration :: Phantoms.TTerm [Syntax.LocalFunctionModifier] -> Phantoms.TTerm Syntax.ReturnType -> Phantoms.TTerm Syntax.LocalFunctionHeader -> Phantoms.TTerm Syntax.LocalFunctionBody -> Phantoms.TTerm Syntax.StandardLocalFunctionDeclaration
standardLocalFunctionDeclaration modifiers returnType header body =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StandardLocalFunctionDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm modifiers)},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Phantoms.unTTerm returnType)},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Phantoms.unTTerm header)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)}]}))

standardLocalFunctionDeclarationBody :: Phantoms.TTerm Syntax.StandardLocalFunctionDeclaration -> Phantoms.TTerm Syntax.LocalFunctionBody
standardLocalFunctionDeclarationBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardLocalFunctionDeclaration"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

standardLocalFunctionDeclarationHeader :: Phantoms.TTerm Syntax.StandardLocalFunctionDeclaration -> Phantoms.TTerm Syntax.LocalFunctionHeader
standardLocalFunctionDeclarationHeader x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardLocalFunctionDeclaration"),
        Core.projectionField = (Core.Name "header")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

standardLocalFunctionDeclarationModifiers :: Phantoms.TTerm Syntax.StandardLocalFunctionDeclaration -> Phantoms.TTerm [Syntax.LocalFunctionModifier]
standardLocalFunctionDeclarationModifiers x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardLocalFunctionDeclaration"),
        Core.projectionField = (Core.Name "modifiers")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

standardLocalFunctionDeclarationReturnType :: Phantoms.TTerm Syntax.StandardLocalFunctionDeclaration -> Phantoms.TTerm Syntax.ReturnType
standardLocalFunctionDeclarationReturnType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardLocalFunctionDeclaration"),
        Core.projectionField = (Core.Name "returnType")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

standardLocalFunctionDeclarationWithBody :: Phantoms.TTerm Syntax.StandardLocalFunctionDeclaration -> Phantoms.TTerm Syntax.LocalFunctionBody -> Phantoms.TTerm Syntax.StandardLocalFunctionDeclaration
standardLocalFunctionDeclarationWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StandardLocalFunctionDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "returnType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "header")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

standardLocalFunctionDeclarationWithHeader :: Phantoms.TTerm Syntax.StandardLocalFunctionDeclaration -> Phantoms.TTerm Syntax.LocalFunctionHeader -> Phantoms.TTerm Syntax.StandardLocalFunctionDeclaration
standardLocalFunctionDeclarationWithHeader original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StandardLocalFunctionDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "returnType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

standardLocalFunctionDeclarationWithModifiers :: Phantoms.TTerm Syntax.StandardLocalFunctionDeclaration -> Phantoms.TTerm [Syntax.LocalFunctionModifier] -> Phantoms.TTerm Syntax.StandardLocalFunctionDeclaration
standardLocalFunctionDeclarationWithModifiers original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StandardLocalFunctionDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "returnType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "header")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

standardLocalFunctionDeclarationWithReturnType :: Phantoms.TTerm Syntax.StandardLocalFunctionDeclaration -> Phantoms.TTerm Syntax.ReturnType -> Phantoms.TTerm Syntax.StandardLocalFunctionDeclaration
standardLocalFunctionDeclarationWithReturnType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StandardLocalFunctionDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "header")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardLocalFunctionDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

standardMethodDeclaration :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm [Syntax.MethodModifier] -> Phantoms.TTerm Syntax.ReturnType -> Phantoms.TTerm Syntax.MethodHeader -> Phantoms.TTerm Syntax.MethodBody -> Phantoms.TTerm Syntax.StandardMethodDeclaration
standardMethodDeclaration attributes modifiers returnType header body =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StandardMethodDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm modifiers)},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Phantoms.unTTerm returnType)},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Phantoms.unTTerm header)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)}]}))

standardMethodDeclarationAttributes :: Phantoms.TTerm Syntax.StandardMethodDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes)
standardMethodDeclarationAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardMethodDeclaration"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

standardMethodDeclarationBody :: Phantoms.TTerm Syntax.StandardMethodDeclaration -> Phantoms.TTerm Syntax.MethodBody
standardMethodDeclarationBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardMethodDeclaration"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

standardMethodDeclarationHeader :: Phantoms.TTerm Syntax.StandardMethodDeclaration -> Phantoms.TTerm Syntax.MethodHeader
standardMethodDeclarationHeader x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardMethodDeclaration"),
        Core.projectionField = (Core.Name "header")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

standardMethodDeclarationModifiers :: Phantoms.TTerm Syntax.StandardMethodDeclaration -> Phantoms.TTerm [Syntax.MethodModifier]
standardMethodDeclarationModifiers x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardMethodDeclaration"),
        Core.projectionField = (Core.Name "modifiers")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

standardMethodDeclarationReturnType :: Phantoms.TTerm Syntax.StandardMethodDeclaration -> Phantoms.TTerm Syntax.ReturnType
standardMethodDeclarationReturnType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardMethodDeclaration"),
        Core.projectionField = (Core.Name "returnType")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

standardMethodDeclarationWithAttributes :: Phantoms.TTerm Syntax.StandardMethodDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.StandardMethodDeclaration
standardMethodDeclarationWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StandardMethodDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardMethodDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardMethodDeclaration"),
              Core.projectionField = (Core.Name "returnType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardMethodDeclaration"),
              Core.projectionField = (Core.Name "header")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardMethodDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

standardMethodDeclarationWithBody :: Phantoms.TTerm Syntax.StandardMethodDeclaration -> Phantoms.TTerm Syntax.MethodBody -> Phantoms.TTerm Syntax.StandardMethodDeclaration
standardMethodDeclarationWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StandardMethodDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardMethodDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardMethodDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardMethodDeclaration"),
              Core.projectionField = (Core.Name "returnType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardMethodDeclaration"),
              Core.projectionField = (Core.Name "header")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

standardMethodDeclarationWithHeader :: Phantoms.TTerm Syntax.StandardMethodDeclaration -> Phantoms.TTerm Syntax.MethodHeader -> Phantoms.TTerm Syntax.StandardMethodDeclaration
standardMethodDeclarationWithHeader original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StandardMethodDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardMethodDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardMethodDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardMethodDeclaration"),
              Core.projectionField = (Core.Name "returnType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardMethodDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

standardMethodDeclarationWithModifiers :: Phantoms.TTerm Syntax.StandardMethodDeclaration -> Phantoms.TTerm [Syntax.MethodModifier] -> Phantoms.TTerm Syntax.StandardMethodDeclaration
standardMethodDeclarationWithModifiers original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StandardMethodDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardMethodDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardMethodDeclaration"),
              Core.projectionField = (Core.Name "returnType")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardMethodDeclaration"),
              Core.projectionField = (Core.Name "header")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardMethodDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

standardMethodDeclarationWithReturnType :: Phantoms.TTerm Syntax.StandardMethodDeclaration -> Phantoms.TTerm Syntax.ReturnType -> Phantoms.TTerm Syntax.StandardMethodDeclaration
standardMethodDeclarationWithReturnType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StandardMethodDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardMethodDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardMethodDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "returnType"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "header"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardMethodDeclaration"),
              Core.projectionField = (Core.Name "header")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardMethodDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

standardPropertyDeclaration :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm [Syntax.PropertyModifier] -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.MemberName -> Phantoms.TTerm Syntax.PropertyBody -> Phantoms.TTerm Syntax.StandardPropertyDeclaration
standardPropertyDeclaration attributes modifiers type_ name body =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm modifiers)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm name)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)}]}))

standardPropertyDeclarationAttributes :: Phantoms.TTerm Syntax.StandardPropertyDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes)
standardPropertyDeclarationAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

standardPropertyDeclarationBody :: Phantoms.TTerm Syntax.StandardPropertyDeclaration -> Phantoms.TTerm Syntax.PropertyBody
standardPropertyDeclarationBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

standardPropertyDeclarationModifiers :: Phantoms.TTerm Syntax.StandardPropertyDeclaration -> Phantoms.TTerm [Syntax.PropertyModifier]
standardPropertyDeclarationModifiers x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration"),
        Core.projectionField = (Core.Name "modifiers")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

standardPropertyDeclarationName :: Phantoms.TTerm Syntax.StandardPropertyDeclaration -> Phantoms.TTerm Syntax.MemberName
standardPropertyDeclarationName x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration"),
        Core.projectionField = (Core.Name "name")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

standardPropertyDeclarationType :: Phantoms.TTerm Syntax.StandardPropertyDeclaration -> Phantoms.TTerm Syntax.Type
standardPropertyDeclarationType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

standardPropertyDeclarationWithAttributes :: Phantoms.TTerm Syntax.StandardPropertyDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.StandardPropertyDeclaration
standardPropertyDeclarationWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

standardPropertyDeclarationWithBody :: Phantoms.TTerm Syntax.StandardPropertyDeclaration -> Phantoms.TTerm Syntax.PropertyBody -> Phantoms.TTerm Syntax.StandardPropertyDeclaration
standardPropertyDeclarationWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

standardPropertyDeclarationWithModifiers :: Phantoms.TTerm Syntax.StandardPropertyDeclaration -> Phantoms.TTerm [Syntax.PropertyModifier] -> Phantoms.TTerm Syntax.StandardPropertyDeclaration
standardPropertyDeclarationWithModifiers original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

standardPropertyDeclarationWithName :: Phantoms.TTerm Syntax.StandardPropertyDeclaration -> Phantoms.TTerm Syntax.MemberName -> Phantoms.TTerm Syntax.StandardPropertyDeclaration
standardPropertyDeclarationWithName original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

standardPropertyDeclarationWithType :: Phantoms.TTerm Syntax.StandardPropertyDeclaration -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.StandardPropertyDeclaration
standardPropertyDeclarationWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StandardPropertyDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

statementDeclaration :: Phantoms.TTerm Syntax.DeclarationStatement -> Phantoms.TTerm Syntax.Statement
statementDeclaration x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.Statement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "declaration"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

statementEmbedded :: Phantoms.TTerm Syntax.EmbeddedStatement -> Phantoms.TTerm Syntax.Statement
statementEmbedded x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.Statement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "embedded"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

statementExpressionAssignment :: Phantoms.TTerm Syntax.Assignment -> Phantoms.TTerm Syntax.StatementExpression
statementExpressionAssignment x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StatementExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "assignment"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

statementExpressionAwait :: Phantoms.TTerm Syntax.UnaryExpression -> Phantoms.TTerm Syntax.StatementExpression
statementExpressionAwait x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StatementExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "await"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

statementExpressionInvocation :: Phantoms.TTerm Syntax.InvocationExpression -> Phantoms.TTerm Syntax.StatementExpression
statementExpressionInvocation x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StatementExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "invocation"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

statementExpressionList :: Phantoms.TTerm [Syntax.StatementExpression] -> Phantoms.TTerm Syntax.StatementExpressionList
statementExpressionList x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.StatementExpressionList"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

statementExpressionNullConditionalInvocation :: Phantoms.TTerm Syntax.NullConditionalInvocationExpression -> Phantoms.TTerm Syntax.StatementExpression
statementExpressionNullConditionalInvocation x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StatementExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "nullConditionalInvocation"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

statementExpressionObjectCreation :: Phantoms.TTerm Syntax.ObjectCreationExpression -> Phantoms.TTerm Syntax.StatementExpression
statementExpressionObjectCreation x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StatementExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "objectCreation"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

statementExpressionPostDecrement :: Phantoms.TTerm Syntax.PrimaryExpression -> Phantoms.TTerm Syntax.StatementExpression
statementExpressionPostDecrement x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StatementExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "postDecrement"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

statementExpressionPostIncrement :: Phantoms.TTerm Syntax.PrimaryExpression -> Phantoms.TTerm Syntax.StatementExpression
statementExpressionPostIncrement x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StatementExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "postIncrement"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

statementExpressionPreDecrement :: Phantoms.TTerm Syntax.UnaryExpression -> Phantoms.TTerm Syntax.StatementExpression
statementExpressionPreDecrement x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StatementExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "preDecrement"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

statementExpressionPreIncrement :: Phantoms.TTerm Syntax.UnaryExpression -> Phantoms.TTerm Syntax.StatementExpression
statementExpressionPreIncrement x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StatementExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "preIncrement"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

statementLabeled :: Phantoms.TTerm Syntax.LabeledStatement -> Phantoms.TTerm Syntax.Statement
statementLabeled x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.Statement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "labeled"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

staticConstructorBodyBlock :: Phantoms.TTerm Syntax.Block -> Phantoms.TTerm Syntax.StaticConstructorBody
staticConstructorBodyBlock x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StaticConstructorBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "block"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

staticConstructorBodyEmpty :: Phantoms.TTerm Syntax.StaticConstructorBody
staticConstructorBodyEmpty =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StaticConstructorBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "empty"),
        Core.fieldTerm = Core.TermUnit}}))

staticConstructorBodyExpression :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.StaticConstructorBody
staticConstructorBodyExpression x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StaticConstructorBody"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "expression"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

staticConstructorDeclaration :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.StaticConstructorModifiers -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.StaticConstructorBody -> Phantoms.TTerm Syntax.StaticConstructorDeclaration
staticConstructorDeclaration attributes modifiers name body =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StaticConstructorDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm modifiers)},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm name)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)}]}))

staticConstructorDeclarationAttributes :: Phantoms.TTerm Syntax.StaticConstructorDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes)
staticConstructorDeclarationAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StaticConstructorDeclaration"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

staticConstructorDeclarationBody :: Phantoms.TTerm Syntax.StaticConstructorDeclaration -> Phantoms.TTerm Syntax.StaticConstructorBody
staticConstructorDeclarationBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StaticConstructorDeclaration"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

staticConstructorDeclarationModifiers :: Phantoms.TTerm Syntax.StaticConstructorDeclaration -> Phantoms.TTerm Syntax.StaticConstructorModifiers
staticConstructorDeclarationModifiers x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StaticConstructorDeclaration"),
        Core.projectionField = (Core.Name "modifiers")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

staticConstructorDeclarationName :: Phantoms.TTerm Syntax.StaticConstructorDeclaration -> Phantoms.TTerm Syntax.Identifier
staticConstructorDeclarationName x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StaticConstructorDeclaration"),
        Core.projectionField = (Core.Name "name")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

staticConstructorDeclarationWithAttributes :: Phantoms.TTerm Syntax.StaticConstructorDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.StaticConstructorDeclaration
staticConstructorDeclarationWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StaticConstructorDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StaticConstructorDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StaticConstructorDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StaticConstructorDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

staticConstructorDeclarationWithBody :: Phantoms.TTerm Syntax.StaticConstructorDeclaration -> Phantoms.TTerm Syntax.StaticConstructorBody -> Phantoms.TTerm Syntax.StaticConstructorDeclaration
staticConstructorDeclarationWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StaticConstructorDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StaticConstructorDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StaticConstructorDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StaticConstructorDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

staticConstructorDeclarationWithModifiers :: Phantoms.TTerm Syntax.StaticConstructorDeclaration -> Phantoms.TTerm Syntax.StaticConstructorModifiers -> Phantoms.TTerm Syntax.StaticConstructorDeclaration
staticConstructorDeclarationWithModifiers original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StaticConstructorDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StaticConstructorDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StaticConstructorDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StaticConstructorDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

staticConstructorDeclarationWithName :: Phantoms.TTerm Syntax.StaticConstructorDeclaration -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.StaticConstructorDeclaration
staticConstructorDeclarationWithName original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StaticConstructorDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StaticConstructorDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StaticConstructorDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StaticConstructorDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

staticConstructorModifiers :: Phantoms.TTerm Bool -> Phantoms.TTerm Bool -> Phantoms.TTerm Syntax.StaticConstructorModifiers
staticConstructorModifiers extern unsafe =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StaticConstructorModifiers"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "extern"),
          Core.fieldTerm = (Phantoms.unTTerm extern)},
        Core.Field {
          Core.fieldName = (Core.Name "unsafe"),
          Core.fieldTerm = (Phantoms.unTTerm unsafe)}]}))

staticConstructorModifiersExtern :: Phantoms.TTerm Syntax.StaticConstructorModifiers -> Phantoms.TTerm Bool
staticConstructorModifiersExtern x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StaticConstructorModifiers"),
        Core.projectionField = (Core.Name "extern")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

staticConstructorModifiersUnsafe :: Phantoms.TTerm Syntax.StaticConstructorModifiers -> Phantoms.TTerm Bool
staticConstructorModifiersUnsafe x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StaticConstructorModifiers"),
        Core.projectionField = (Core.Name "unsafe")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

staticConstructorModifiersWithExtern :: Phantoms.TTerm Syntax.StaticConstructorModifiers -> Phantoms.TTerm Bool -> Phantoms.TTerm Syntax.StaticConstructorModifiers
staticConstructorModifiersWithExtern original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StaticConstructorModifiers"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "extern"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "unsafe"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StaticConstructorModifiers"),
              Core.projectionField = (Core.Name "unsafe")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

staticConstructorModifiersWithUnsafe :: Phantoms.TTerm Syntax.StaticConstructorModifiers -> Phantoms.TTerm Bool -> Phantoms.TTerm Syntax.StaticConstructorModifiers
staticConstructorModifiersWithUnsafe original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StaticConstructorModifiers"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "extern"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StaticConstructorModifiers"),
              Core.projectionField = (Core.Name "extern")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "unsafe"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

structDeclaration :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm [Syntax.StructModifier] -> Phantoms.TTerm Bool -> Phantoms.TTerm Bool -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm (Maybe Syntax.TypeParameterList) -> Phantoms.TTerm [Syntax.InterfaceType] -> Phantoms.TTerm [Syntax.TypeParameterConstraintsClause] -> Phantoms.TTerm [Syntax.StructMemberDeclaration] -> Phantoms.TTerm Syntax.StructDeclaration
structDeclaration attributes modifiers ref partial name parameters interfaces constraints body =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm modifiers)},
        Core.Field {
          Core.fieldName = (Core.Name "ref"),
          Core.fieldTerm = (Phantoms.unTTerm ref)},
        Core.Field {
          Core.fieldName = (Core.Name "partial"),
          Core.fieldTerm = (Phantoms.unTTerm partial)},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm name)},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Phantoms.unTTerm parameters)},
        Core.Field {
          Core.fieldName = (Core.Name "interfaces"),
          Core.fieldTerm = (Phantoms.unTTerm interfaces)},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Phantoms.unTTerm constraints)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)}]}))

structDeclarationAttributes :: Phantoms.TTerm Syntax.StructDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes)
structDeclarationAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

structDeclarationBody :: Phantoms.TTerm Syntax.StructDeclaration -> Phantoms.TTerm [Syntax.StructMemberDeclaration]
structDeclarationBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

structDeclarationConstraints :: Phantoms.TTerm Syntax.StructDeclaration -> Phantoms.TTerm [Syntax.TypeParameterConstraintsClause]
structDeclarationConstraints x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
        Core.projectionField = (Core.Name "constraints")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

structDeclarationInterfaces :: Phantoms.TTerm Syntax.StructDeclaration -> Phantoms.TTerm [Syntax.InterfaceType]
structDeclarationInterfaces x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
        Core.projectionField = (Core.Name "interfaces")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

structDeclarationModifiers :: Phantoms.TTerm Syntax.StructDeclaration -> Phantoms.TTerm [Syntax.StructModifier]
structDeclarationModifiers x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
        Core.projectionField = (Core.Name "modifiers")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

structDeclarationName :: Phantoms.TTerm Syntax.StructDeclaration -> Phantoms.TTerm Syntax.Identifier
structDeclarationName x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
        Core.projectionField = (Core.Name "name")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

structDeclarationParameters :: Phantoms.TTerm Syntax.StructDeclaration -> Phantoms.TTerm (Maybe Syntax.TypeParameterList)
structDeclarationParameters x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
        Core.projectionField = (Core.Name "parameters")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

structDeclarationPartial :: Phantoms.TTerm Syntax.StructDeclaration -> Phantoms.TTerm Bool
structDeclarationPartial x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
        Core.projectionField = (Core.Name "partial")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

structDeclarationRef :: Phantoms.TTerm Syntax.StructDeclaration -> Phantoms.TTerm Bool
structDeclarationRef x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
        Core.projectionField = (Core.Name "ref")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

structDeclarationWithAttributes :: Phantoms.TTerm Syntax.StructDeclaration -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.StructDeclaration
structDeclarationWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "ref"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "ref")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "partial"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "partial")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "interfaces"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "interfaces")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

structDeclarationWithBody :: Phantoms.TTerm Syntax.StructDeclaration -> Phantoms.TTerm [Syntax.StructMemberDeclaration] -> Phantoms.TTerm Syntax.StructDeclaration
structDeclarationWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "ref"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "ref")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "partial"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "partial")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "interfaces"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "interfaces")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

structDeclarationWithConstraints :: Phantoms.TTerm Syntax.StructDeclaration -> Phantoms.TTerm [Syntax.TypeParameterConstraintsClause] -> Phantoms.TTerm Syntax.StructDeclaration
structDeclarationWithConstraints original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "ref"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "ref")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "partial"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "partial")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "interfaces"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "interfaces")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

structDeclarationWithInterfaces :: Phantoms.TTerm Syntax.StructDeclaration -> Phantoms.TTerm [Syntax.InterfaceType] -> Phantoms.TTerm Syntax.StructDeclaration
structDeclarationWithInterfaces original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "ref"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "ref")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "partial"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "partial")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "interfaces"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

structDeclarationWithModifiers :: Phantoms.TTerm Syntax.StructDeclaration -> Phantoms.TTerm [Syntax.StructModifier] -> Phantoms.TTerm Syntax.StructDeclaration
structDeclarationWithModifiers original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "ref"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "ref")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "partial"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "partial")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "interfaces"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "interfaces")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

structDeclarationWithName :: Phantoms.TTerm Syntax.StructDeclaration -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.StructDeclaration
structDeclarationWithName original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "ref"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "ref")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "partial"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "partial")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "interfaces"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "interfaces")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

structDeclarationWithParameters :: Phantoms.TTerm Syntax.StructDeclaration -> Phantoms.TTerm (Maybe Syntax.TypeParameterList) -> Phantoms.TTerm Syntax.StructDeclaration
structDeclarationWithParameters original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "ref"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "ref")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "partial"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "partial")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "interfaces"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "interfaces")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

structDeclarationWithPartial :: Phantoms.TTerm Syntax.StructDeclaration -> Phantoms.TTerm Bool -> Phantoms.TTerm Syntax.StructDeclaration
structDeclarationWithPartial original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "ref"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "ref")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "partial"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "interfaces"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "interfaces")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

structDeclarationWithRef :: Phantoms.TTerm Syntax.StructDeclaration -> Phantoms.TTerm Bool -> Phantoms.TTerm Syntax.StructDeclaration
structDeclarationWithRef original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "modifiers"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "modifiers")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "ref"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "partial"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "partial")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameters"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "parameters")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "interfaces"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "interfaces")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.StructDeclaration"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

structMemberDeclarationConstant :: Phantoms.TTerm Syntax.ConstantDeclaration -> Phantoms.TTerm Syntax.StructMemberDeclaration
structMemberDeclarationConstant x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StructMemberDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "constant"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

structMemberDeclarationConstructor :: Phantoms.TTerm Syntax.ConstructorDeclaration -> Phantoms.TTerm Syntax.StructMemberDeclaration
structMemberDeclarationConstructor x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StructMemberDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "constructor"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

structMemberDeclarationEvent :: Phantoms.TTerm Syntax.EventDeclaration -> Phantoms.TTerm Syntax.StructMemberDeclaration
structMemberDeclarationEvent x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StructMemberDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "event"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

structMemberDeclarationField :: Phantoms.TTerm Syntax.FieldDeclaration -> Phantoms.TTerm Syntax.StructMemberDeclaration
structMemberDeclarationField x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StructMemberDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "field"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

structMemberDeclarationFixedSizeBuffer :: Phantoms.TTerm Syntax.FixedSizeBufferDeclaration -> Phantoms.TTerm Syntax.StructMemberDeclaration
structMemberDeclarationFixedSizeBuffer x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StructMemberDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "fixedSizeBuffer"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

structMemberDeclarationIndexer :: Phantoms.TTerm Syntax.IndexerDeclaration -> Phantoms.TTerm Syntax.StructMemberDeclaration
structMemberDeclarationIndexer x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StructMemberDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "indexer"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

structMemberDeclarationMethod :: Phantoms.TTerm Syntax.MethodDeclaration -> Phantoms.TTerm Syntax.StructMemberDeclaration
structMemberDeclarationMethod x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StructMemberDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "method"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

structMemberDeclarationOperator :: Phantoms.TTerm Syntax.OperatorDeclaration -> Phantoms.TTerm Syntax.StructMemberDeclaration
structMemberDeclarationOperator x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StructMemberDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "operator"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

structMemberDeclarationProperty :: Phantoms.TTerm Syntax.PropertyDeclaration -> Phantoms.TTerm Syntax.StructMemberDeclaration
structMemberDeclarationProperty x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StructMemberDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "property"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

structMemberDeclarationStaticConstructor :: Phantoms.TTerm Syntax.StaticConstructorDeclaration -> Phantoms.TTerm Syntax.StructMemberDeclaration
structMemberDeclarationStaticConstructor x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StructMemberDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "staticConstructor"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

structMemberDeclarationType :: Phantoms.TTerm Syntax.TypeDeclaration -> Phantoms.TTerm Syntax.StructMemberDeclaration
structMemberDeclarationType x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StructMemberDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "type"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

structModifierInternal :: Phantoms.TTerm Syntax.StructModifier
structModifierInternal =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StructModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "internal"),
        Core.fieldTerm = Core.TermUnit}}))

structModifierNew :: Phantoms.TTerm Syntax.StructModifier
structModifierNew =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StructModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "new"),
        Core.fieldTerm = Core.TermUnit}}))

structModifierPrivate :: Phantoms.TTerm Syntax.StructModifier
structModifierPrivate =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StructModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "private"),
        Core.fieldTerm = Core.TermUnit}}))

structModifierProtected :: Phantoms.TTerm Syntax.StructModifier
structModifierProtected =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StructModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "protected"),
        Core.fieldTerm = Core.TermUnit}}))

structModifierPublic :: Phantoms.TTerm Syntax.StructModifier
structModifierPublic =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StructModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "public"),
        Core.fieldTerm = Core.TermUnit}}))

structModifierReadonly :: Phantoms.TTerm Syntax.StructModifier
structModifierReadonly =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StructModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "readonly"),
        Core.fieldTerm = Core.TermUnit}}))

structModifierUnsafe :: Phantoms.TTerm Syntax.StructModifier
structModifierUnsafe =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StructModifier"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "unsafe"),
        Core.fieldTerm = Core.TermUnit}}))

structOrEnumTypeEnum :: Phantoms.TTerm Syntax.EnumType -> Phantoms.TTerm Syntax.StructOrEnumType
structOrEnumTypeEnum x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StructOrEnumType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "enum"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

structOrEnumTypeStruct :: Phantoms.TTerm Syntax.StructType -> Phantoms.TTerm Syntax.StructOrEnumType
structOrEnumTypeStruct x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StructOrEnumType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "struct"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

structTypeSimple :: Phantoms.TTerm Syntax.SimpleType -> Phantoms.TTerm Syntax.StructType
structTypeSimple x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StructType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "simple"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

structTypeTuple :: Phantoms.TTerm Syntax.TupleType -> Phantoms.TTerm Syntax.StructType
structTypeTuple x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StructType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "tuple"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

structTypeTypeName :: Phantoms.TTerm Syntax.TypeName -> Phantoms.TTerm Syntax.StructType
structTypeTypeName x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.StructType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "typeName"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

switchBranch :: Phantoms.TTerm Syntax.Pattern -> Phantoms.TTerm (Maybe Syntax.Expression) -> Phantoms.TTerm Syntax.SwitchBranch
switchBranch pattern guard =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.SwitchBranch"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "pattern"),
          Core.fieldTerm = (Phantoms.unTTerm pattern)},
        Core.Field {
          Core.fieldName = (Core.Name "guard"),
          Core.fieldTerm = (Phantoms.unTTerm guard)}]}))

switchBranchGuard :: Phantoms.TTerm Syntax.SwitchBranch -> Phantoms.TTerm (Maybe Syntax.Expression)
switchBranchGuard x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SwitchBranch"),
        Core.projectionField = (Core.Name "guard")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

switchBranchPattern :: Phantoms.TTerm Syntax.SwitchBranch -> Phantoms.TTerm Syntax.Pattern
switchBranchPattern x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SwitchBranch"),
        Core.projectionField = (Core.Name "pattern")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

switchBranchWithGuard :: Phantoms.TTerm Syntax.SwitchBranch -> Phantoms.TTerm (Maybe Syntax.Expression) -> Phantoms.TTerm Syntax.SwitchBranch
switchBranchWithGuard original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.SwitchBranch"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "pattern"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SwitchBranch"),
              Core.projectionField = (Core.Name "pattern")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "guard"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

switchBranchWithPattern :: Phantoms.TTerm Syntax.SwitchBranch -> Phantoms.TTerm Syntax.Pattern -> Phantoms.TTerm Syntax.SwitchBranch
switchBranchWithPattern original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.SwitchBranch"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "pattern"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "guard"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SwitchBranch"),
              Core.projectionField = (Core.Name "guard")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

switchLabelBranch :: Phantoms.TTerm Syntax.SwitchBranch -> Phantoms.TTerm Syntax.SwitchLabel
switchLabelBranch x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.SwitchLabel"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "branch"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

switchLabelDefault :: Phantoms.TTerm Syntax.SwitchLabel
switchLabelDefault =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.SwitchLabel"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "default"),
        Core.fieldTerm = Core.TermUnit}}))

switchSection :: Phantoms.TTerm [Syntax.SwitchLabel] -> Phantoms.TTerm [Syntax.Statement] -> Phantoms.TTerm Syntax.SwitchSection
switchSection labels statements =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.SwitchSection"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "labels"),
          Core.fieldTerm = (Phantoms.unTTerm labels)},
        Core.Field {
          Core.fieldName = (Core.Name "statements"),
          Core.fieldTerm = (Phantoms.unTTerm statements)}]}))

switchSectionLabels :: Phantoms.TTerm Syntax.SwitchSection -> Phantoms.TTerm [Syntax.SwitchLabel]
switchSectionLabels x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SwitchSection"),
        Core.projectionField = (Core.Name "labels")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

switchSectionStatements :: Phantoms.TTerm Syntax.SwitchSection -> Phantoms.TTerm [Syntax.Statement]
switchSectionStatements x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SwitchSection"),
        Core.projectionField = (Core.Name "statements")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

switchSectionWithLabels :: Phantoms.TTerm Syntax.SwitchSection -> Phantoms.TTerm [Syntax.SwitchLabel] -> Phantoms.TTerm Syntax.SwitchSection
switchSectionWithLabels original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.SwitchSection"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "labels"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "statements"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SwitchSection"),
              Core.projectionField = (Core.Name "statements")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

switchSectionWithStatements :: Phantoms.TTerm Syntax.SwitchSection -> Phantoms.TTerm [Syntax.Statement] -> Phantoms.TTerm Syntax.SwitchSection
switchSectionWithStatements original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.SwitchSection"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "labels"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SwitchSection"),
              Core.projectionField = (Core.Name "labels")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "statements"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

switchStatement :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm [Syntax.SwitchSection] -> Phantoms.TTerm Syntax.SwitchStatement
switchStatement expression branches =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.SwitchStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm expression)},
        Core.Field {
          Core.fieldName = (Core.Name "branches"),
          Core.fieldTerm = (Phantoms.unTTerm branches)}]}))

switchStatementBranches :: Phantoms.TTerm Syntax.SwitchStatement -> Phantoms.TTerm [Syntax.SwitchSection]
switchStatementBranches x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SwitchStatement"),
        Core.projectionField = (Core.Name "branches")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

switchStatementExpression :: Phantoms.TTerm Syntax.SwitchStatement -> Phantoms.TTerm Syntax.Expression
switchStatementExpression x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SwitchStatement"),
        Core.projectionField = (Core.Name "expression")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

switchStatementWithBranches :: Phantoms.TTerm Syntax.SwitchStatement -> Phantoms.TTerm [Syntax.SwitchSection] -> Phantoms.TTerm Syntax.SwitchStatement
switchStatementWithBranches original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.SwitchStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SwitchStatement"),
              Core.projectionField = (Core.Name "expression")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "branches"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

switchStatementWithExpression :: Phantoms.TTerm Syntax.SwitchStatement -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.SwitchStatement
switchStatementWithExpression original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.SwitchStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "branches"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.SwitchStatement"),
              Core.projectionField = (Core.Name "branches")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

tryStatement :: Phantoms.TTerm Syntax.Block -> Phantoms.TTerm Syntax.CatchClauses -> Phantoms.TTerm (Maybe Syntax.Block) -> Phantoms.TTerm Syntax.TryStatement
tryStatement body catches finally =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.TryStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)},
        Core.Field {
          Core.fieldName = (Core.Name "catches"),
          Core.fieldTerm = (Phantoms.unTTerm catches)},
        Core.Field {
          Core.fieldName = (Core.Name "finally"),
          Core.fieldTerm = (Phantoms.unTTerm finally)}]}))

tryStatementBody :: Phantoms.TTerm Syntax.TryStatement -> Phantoms.TTerm Syntax.Block
tryStatementBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TryStatement"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

tryStatementCatches :: Phantoms.TTerm Syntax.TryStatement -> Phantoms.TTerm Syntax.CatchClauses
tryStatementCatches x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TryStatement"),
        Core.projectionField = (Core.Name "catches")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

tryStatementFinally :: Phantoms.TTerm Syntax.TryStatement -> Phantoms.TTerm (Maybe Syntax.Block)
tryStatementFinally x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TryStatement"),
        Core.projectionField = (Core.Name "finally")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

tryStatementWithBody :: Phantoms.TTerm Syntax.TryStatement -> Phantoms.TTerm Syntax.Block -> Phantoms.TTerm Syntax.TryStatement
tryStatementWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.TryStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "catches"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TryStatement"),
              Core.projectionField = (Core.Name "catches")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "finally"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TryStatement"),
              Core.projectionField = (Core.Name "finally")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

tryStatementWithCatches :: Phantoms.TTerm Syntax.TryStatement -> Phantoms.TTerm Syntax.CatchClauses -> Phantoms.TTerm Syntax.TryStatement
tryStatementWithCatches original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.TryStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TryStatement"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "catches"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "finally"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TryStatement"),
              Core.projectionField = (Core.Name "finally")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

tryStatementWithFinally :: Phantoms.TTerm Syntax.TryStatement -> Phantoms.TTerm (Maybe Syntax.Block) -> Phantoms.TTerm Syntax.TryStatement
tryStatementWithFinally original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.TryStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TryStatement"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "catches"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TryStatement"),
              Core.projectionField = (Core.Name "catches")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "finally"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

tupleElement :: Phantoms.TTerm (Maybe Syntax.Identifier) -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.TupleElement
tupleElement name expression =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.TupleElement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm name)},
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm expression)}]}))

tupleElementExpression :: Phantoms.TTerm Syntax.TupleElement -> Phantoms.TTerm Syntax.Expression
tupleElementExpression x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TupleElement"),
        Core.projectionField = (Core.Name "expression")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

tupleElementName :: Phantoms.TTerm Syntax.TupleElement -> Phantoms.TTerm (Maybe Syntax.Identifier)
tupleElementName x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TupleElement"),
        Core.projectionField = (Core.Name "name")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

tupleElementWithExpression :: Phantoms.TTerm Syntax.TupleElement -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.TupleElement
tupleElementWithExpression original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.TupleElement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TupleElement"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

tupleElementWithName :: Phantoms.TTerm Syntax.TupleElement -> Phantoms.TTerm (Maybe Syntax.Identifier) -> Phantoms.TTerm Syntax.TupleElement
tupleElementWithName original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.TupleElement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TupleElement"),
              Core.projectionField = (Core.Name "expression")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

tupleExpressionDeconstruction :: Phantoms.TTerm Syntax.DeconstructionTuple -> Phantoms.TTerm Syntax.TupleExpression
tupleExpressionDeconstruction x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.TupleExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "deconstruction"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

tupleExpressionElements :: Phantoms.TTerm [Syntax.TupleElement] -> Phantoms.TTerm Syntax.TupleExpression
tupleExpressionElements x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.TupleExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "elements"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

tupleType :: Phantoms.TTerm [Syntax.TupleTypeElement] -> Phantoms.TTerm Syntax.TupleType
tupleType x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.TupleType"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

tupleTypeElement :: Phantoms.TTerm Syntax.Type -> Phantoms.TTerm (Maybe Syntax.Identifier) -> Phantoms.TTerm Syntax.TupleTypeElement
tupleTypeElement type_ identifier =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.TupleTypeElement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm identifier)}]}))

tupleTypeElementIdentifier :: Phantoms.TTerm Syntax.TupleTypeElement -> Phantoms.TTerm (Maybe Syntax.Identifier)
tupleTypeElementIdentifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TupleTypeElement"),
        Core.projectionField = (Core.Name "identifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

tupleTypeElementType :: Phantoms.TTerm Syntax.TupleTypeElement -> Phantoms.TTerm Syntax.Type
tupleTypeElementType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TupleTypeElement"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

tupleTypeElementWithIdentifier :: Phantoms.TTerm Syntax.TupleTypeElement -> Phantoms.TTerm (Maybe Syntax.Identifier) -> Phantoms.TTerm Syntax.TupleTypeElement
tupleTypeElementWithIdentifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.TupleTypeElement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TupleTypeElement"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

tupleTypeElementWithType :: Phantoms.TTerm Syntax.TupleTypeElement -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.TupleTypeElement
tupleTypeElementWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.TupleTypeElement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TupleTypeElement"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

typeArgumentList :: Phantoms.TTerm [Syntax.Type] -> Phantoms.TTerm Syntax.TypeArgumentList
typeArgumentList x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.TypeArgumentList"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

typeDeclarationClass :: Phantoms.TTerm Syntax.ClassDeclaration -> Phantoms.TTerm Syntax.TypeDeclaration
typeDeclarationClass x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.TypeDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "class"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

typeDeclarationDelegate :: Phantoms.TTerm Syntax.DelegateDeclaration -> Phantoms.TTerm Syntax.TypeDeclaration
typeDeclarationDelegate x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.TypeDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "delegate"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

typeDeclarationEnum :: Phantoms.TTerm Syntax.EnumDeclaration -> Phantoms.TTerm Syntax.TypeDeclaration
typeDeclarationEnum x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.TypeDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "enum"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

typeDeclarationInterface :: Phantoms.TTerm Syntax.InterfaceDeclaration -> Phantoms.TTerm Syntax.TypeDeclaration
typeDeclarationInterface x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.TypeDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "interface"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

typeDeclarationStruct :: Phantoms.TTerm Syntax.StructDeclaration -> Phantoms.TTerm Syntax.TypeDeclaration
typeDeclarationStruct x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.TypeDeclaration"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "struct"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

typeName :: Phantoms.TTerm Syntax.NamespaceOrTypeName -> Phantoms.TTerm Syntax.TypeName
typeName x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.TypeName"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

typeParam :: Phantoms.TTerm Syntax.TypeParameter -> Phantoms.TTerm Syntax.Type
typeParam x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.Type"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "param"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

typeParameter :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.TypeParameter
typeParameter x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.TypeParameter"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

typeParameterConstraints :: Phantoms.TTerm (Maybe Syntax.PrimaryConstraint) -> Phantoms.TTerm (Maybe Syntax.SecondaryConstraints) -> Phantoms.TTerm Bool -> Phantoms.TTerm Syntax.TypeParameterConstraints
typeParameterConstraints primary secondary constructor =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.TypeParameterConstraints"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "primary"),
          Core.fieldTerm = (Phantoms.unTTerm primary)},
        Core.Field {
          Core.fieldName = (Core.Name "secondary"),
          Core.fieldTerm = (Phantoms.unTTerm secondary)},
        Core.Field {
          Core.fieldName = (Core.Name "constructor"),
          Core.fieldTerm = (Phantoms.unTTerm constructor)}]}))

typeParameterConstraintsClause :: Phantoms.TTerm Syntax.TypeParameter -> Phantoms.TTerm [Syntax.TypeParameterConstraints] -> Phantoms.TTerm Syntax.TypeParameterConstraintsClause
typeParameterConstraintsClause parameter constraints =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.TypeParameterConstraintsClause"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "parameter"),
          Core.fieldTerm = (Phantoms.unTTerm parameter)},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Phantoms.unTTerm constraints)}]}))

typeParameterConstraintsClauseConstraints :: Phantoms.TTerm Syntax.TypeParameterConstraintsClause -> Phantoms.TTerm [Syntax.TypeParameterConstraints]
typeParameterConstraintsClauseConstraints x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TypeParameterConstraintsClause"),
        Core.projectionField = (Core.Name "constraints")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

typeParameterConstraintsClauseParameter :: Phantoms.TTerm Syntax.TypeParameterConstraintsClause -> Phantoms.TTerm Syntax.TypeParameter
typeParameterConstraintsClauseParameter x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TypeParameterConstraintsClause"),
        Core.projectionField = (Core.Name "parameter")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

typeParameterConstraintsClauseWithConstraints :: Phantoms.TTerm Syntax.TypeParameterConstraintsClause -> Phantoms.TTerm [Syntax.TypeParameterConstraints] -> Phantoms.TTerm Syntax.TypeParameterConstraintsClause
typeParameterConstraintsClauseWithConstraints original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.TypeParameterConstraintsClause"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "parameter"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TypeParameterConstraintsClause"),
              Core.projectionField = (Core.Name "parameter")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

typeParameterConstraintsClauseWithParameter :: Phantoms.TTerm Syntax.TypeParameterConstraintsClause -> Phantoms.TTerm Syntax.TypeParameter -> Phantoms.TTerm Syntax.TypeParameterConstraintsClause
typeParameterConstraintsClauseWithParameter original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.TypeParameterConstraintsClause"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "parameter"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "constraints"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TypeParameterConstraintsClause"),
              Core.projectionField = (Core.Name "constraints")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

typeParameterConstraintsConstructor :: Phantoms.TTerm Syntax.TypeParameterConstraints -> Phantoms.TTerm Bool
typeParameterConstraintsConstructor x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TypeParameterConstraints"),
        Core.projectionField = (Core.Name "constructor")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

typeParameterConstraintsPrimary :: Phantoms.TTerm Syntax.TypeParameterConstraints -> Phantoms.TTerm (Maybe Syntax.PrimaryConstraint)
typeParameterConstraintsPrimary x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TypeParameterConstraints"),
        Core.projectionField = (Core.Name "primary")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

typeParameterConstraintsSecondary :: Phantoms.TTerm Syntax.TypeParameterConstraints -> Phantoms.TTerm (Maybe Syntax.SecondaryConstraints)
typeParameterConstraintsSecondary x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TypeParameterConstraints"),
        Core.projectionField = (Core.Name "secondary")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

typeParameterConstraintsWithConstructor :: Phantoms.TTerm Syntax.TypeParameterConstraints -> Phantoms.TTerm Bool -> Phantoms.TTerm Syntax.TypeParameterConstraints
typeParameterConstraintsWithConstructor original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.TypeParameterConstraints"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "primary"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TypeParameterConstraints"),
              Core.projectionField = (Core.Name "primary")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "secondary"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TypeParameterConstraints"),
              Core.projectionField = (Core.Name "secondary")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constructor"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

typeParameterConstraintsWithPrimary :: Phantoms.TTerm Syntax.TypeParameterConstraints -> Phantoms.TTerm (Maybe Syntax.PrimaryConstraint) -> Phantoms.TTerm Syntax.TypeParameterConstraints
typeParameterConstraintsWithPrimary original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.TypeParameterConstraints"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "primary"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "secondary"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TypeParameterConstraints"),
              Core.projectionField = (Core.Name "secondary")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "constructor"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TypeParameterConstraints"),
              Core.projectionField = (Core.Name "constructor")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

typeParameterConstraintsWithSecondary :: Phantoms.TTerm Syntax.TypeParameterConstraints -> Phantoms.TTerm (Maybe Syntax.SecondaryConstraints) -> Phantoms.TTerm Syntax.TypeParameterConstraints
typeParameterConstraintsWithSecondary original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.TypeParameterConstraints"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "primary"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TypeParameterConstraints"),
              Core.projectionField = (Core.Name "primary")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "secondary"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "constructor"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TypeParameterConstraints"),
              Core.projectionField = (Core.Name "constructor")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

typeParameterList :: Phantoms.TTerm [Syntax.TypeParameterPart] -> Phantoms.TTerm Syntax.TypeParameterList
typeParameterList x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.TypeParameterList"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

typeParameterPart :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.TypeParameter -> Phantoms.TTerm Syntax.TypeParameterPart
typeParameterPart attributes name =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.TypeParameterPart"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm name)}]}))

typeParameterPartAttributes :: Phantoms.TTerm Syntax.TypeParameterPart -> Phantoms.TTerm (Maybe Syntax.Attributes)
typeParameterPartAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TypeParameterPart"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

typeParameterPartName :: Phantoms.TTerm Syntax.TypeParameterPart -> Phantoms.TTerm Syntax.TypeParameter
typeParameterPartName x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TypeParameterPart"),
        Core.projectionField = (Core.Name "name")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

typeParameterPartWithAttributes :: Phantoms.TTerm Syntax.TypeParameterPart -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.TypeParameterPart
typeParameterPartWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.TypeParameterPart"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TypeParameterPart"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

typeParameterPartWithName :: Phantoms.TTerm Syntax.TypeParameterPart -> Phantoms.TTerm Syntax.TypeParameter -> Phantoms.TTerm Syntax.TypeParameterPart
typeParameterPartWithName original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.TypeParameterPart"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.TypeParameterPart"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

typePointer :: Phantoms.TTerm Syntax.PointerType -> Phantoms.TTerm Syntax.Type
typePointer x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.Type"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "pointer"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

typeReference :: Phantoms.TTerm Syntax.ReferenceType -> Phantoms.TTerm Syntax.Type
typeReference x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.Type"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "reference"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

typeValue :: Phantoms.TTerm Syntax.ValueType -> Phantoms.TTerm Syntax.Type
typeValue x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.Type"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "value"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

typeofExpressionType :: Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.TypeofExpression
typeofExpressionType x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.TypeofExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "type"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

typeofExpressionUnboundTypeName :: Phantoms.TTerm Syntax.UnboundTypeName -> Phantoms.TTerm Syntax.TypeofExpression
typeofExpressionUnboundTypeName x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.TypeofExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "unboundTypeName"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

typeofExpressionVoid :: Phantoms.TTerm Syntax.TypeofExpression
typeofExpressionVoid =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.TypeofExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "void"),
        Core.fieldTerm = Core.TermUnit}}))

unArgumentList :: Phantoms.TTerm Syntax.ArgumentList -> Phantoms.TTerm [Syntax.Argument]
unArgumentList x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.ArgumentList")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unArrayInitializer :: Phantoms.TTerm Syntax.ArrayInitializer -> Phantoms.TTerm [Syntax.VariableInitializer]
unArrayInitializer x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.ArrayInitializer")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unAttributeArgumentExpression :: Phantoms.TTerm Syntax.AttributeArgumentExpression -> Phantoms.TTerm Syntax.NonAssignmentExpression
unAttributeArgumentExpression x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.AttributeArgumentExpression")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unAttributeList :: Phantoms.TTerm Syntax.AttributeList -> Phantoms.TTerm [Syntax.Attribute]
unAttributeList x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.AttributeList")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unAttributeName :: Phantoms.TTerm Syntax.AttributeName -> Phantoms.TTerm Syntax.TypeName
unAttributeName x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.AttributeName")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unAttributes :: Phantoms.TTerm Syntax.Attributes -> Phantoms.TTerm [Syntax.AttributeSection]
unAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.Attributes")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unBlock :: Phantoms.TTerm Syntax.Block -> Phantoms.TTerm [Syntax.Statement]
unBlock x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.Block")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unBooleanExpression :: Phantoms.TTerm Syntax.BooleanExpression -> Phantoms.TTerm Syntax.Expression
unBooleanExpression x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.BooleanExpression")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unClassBody :: Phantoms.TTerm Syntax.ClassBody -> Phantoms.TTerm [Syntax.ClassMemberDeclaration]
unClassBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.ClassBody")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unConstantExpression :: Phantoms.TTerm Syntax.ConstantExpression -> Phantoms.TTerm Syntax.Expression
unConstantExpression x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.ConstantExpression")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unDeconstructionTuple :: Phantoms.TTerm Syntax.DeconstructionTuple -> Phantoms.TTerm [Syntax.DeconstructionElement]
unDeconstructionTuple x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.DeconstructionTuple")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unDelegateType :: Phantoms.TTerm Syntax.DelegateType -> Phantoms.TTerm Syntax.TypeName
unDelegateType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.DelegateType")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unDesignation :: Phantoms.TTerm Syntax.Designation -> Phantoms.TTerm Syntax.Identifier
unDesignation x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.Designation")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unEnumBody :: Phantoms.TTerm Syntax.EnumBody -> Phantoms.TTerm [Syntax.EnumMemberDeclaration]
unEnumBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.EnumBody")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unEnumType :: Phantoms.TTerm Syntax.EnumType -> Phantoms.TTerm Syntax.TypeName
unEnumType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.EnumType")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unExpressionList :: Phantoms.TTerm Syntax.ExpressionList -> Phantoms.TTerm [Syntax.Expression]
unExpressionList x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.ExpressionList")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unExternAliasDirective :: Phantoms.TTerm Syntax.ExternAliasDirective -> Phantoms.TTerm Syntax.Identifier
unExternAliasDirective x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.ExternAliasDirective")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unIdentifier :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm String
unIdentifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.Identifier")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unInterfaceType :: Phantoms.TTerm Syntax.InterfaceType -> Phantoms.TTerm Syntax.TypeName
unInterfaceType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.InterfaceType")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unInterpolatedRegularStringExpression :: Phantoms.TTerm Syntax.InterpolatedRegularStringExpression -> Phantoms.TTerm String
unInterpolatedRegularStringExpression x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.InterpolatedRegularStringExpression")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unInterpolatedVerbatimStringExpression :: Phantoms.TTerm Syntax.InterpolatedVerbatimStringExpression -> Phantoms.TTerm String
unInterpolatedVerbatimStringExpression x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.InterpolatedVerbatimStringExpression")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unKeyword :: Phantoms.TTerm Syntax.Keyword -> Phantoms.TTerm String
unKeyword x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.Keyword")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unMemberDeclaratorList :: Phantoms.TTerm Syntax.MemberDeclaratorList -> Phantoms.TTerm [Syntax.MemberDeclarator]
unMemberDeclaratorList x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.MemberDeclaratorList")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unNamedArgumentList :: Phantoms.TTerm Syntax.NamedArgumentList -> Phantoms.TTerm [Syntax.NamedArgument]
unNamedArgumentList x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.NamedArgumentList")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unNamespaceName :: Phantoms.TTerm Syntax.NamespaceName -> Phantoms.TTerm Syntax.NamespaceOrTypeName
unNamespaceName x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.NamespaceName")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unPositionalArgumentList :: Phantoms.TTerm Syntax.PositionalArgumentList -> Phantoms.TTerm [Syntax.PositionalArgument]
unPositionalArgumentList x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.PositionalArgumentList")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unQualifiedIdentifier :: Phantoms.TTerm Syntax.QualifiedIdentifier -> Phantoms.TTerm [Syntax.Identifier]
unQualifiedIdentifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.QualifiedIdentifier")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unRankSpecifier :: Phantoms.TTerm Syntax.RankSpecifier -> Phantoms.TTerm Int
unRankSpecifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.RankSpecifier")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unSecondaryConstraints :: Phantoms.TTerm Syntax.SecondaryConstraints -> Phantoms.TTerm [Syntax.SecondaryConstraint]
unSecondaryConstraints x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.SecondaryConstraints")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unStatementExpressionList :: Phantoms.TTerm Syntax.StatementExpressionList -> Phantoms.TTerm [Syntax.StatementExpression]
unStatementExpressionList x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.StatementExpressionList")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unTupleType :: Phantoms.TTerm Syntax.TupleType -> Phantoms.TTerm [Syntax.TupleTypeElement]
unTupleType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.TupleType")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unTypeArgumentList :: Phantoms.TTerm Syntax.TypeArgumentList -> Phantoms.TTerm [Syntax.Type]
unTypeArgumentList x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.TypeArgumentList")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unTypeName :: Phantoms.TTerm Syntax.TypeName -> Phantoms.TTerm Syntax.NamespaceOrTypeName
unTypeName x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.TypeName")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unTypeParameter :: Phantoms.TTerm Syntax.TypeParameter -> Phantoms.TTerm Syntax.Identifier
unTypeParameter x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.TypeParameter")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unTypeParameterList :: Phantoms.TTerm Syntax.TypeParameterList -> Phantoms.TTerm [Syntax.TypeParameterPart]
unTypeParameterList x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.TypeParameterList")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unUnboundTypeName :: Phantoms.TTerm Syntax.UnboundTypeName -> Phantoms.TTerm [Syntax.UnboundTypeNamePart]
unUnboundTypeName x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.UnboundTypeName")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unVariableDeclarators :: Phantoms.TTerm Syntax.VariableDeclarators -> Phantoms.TTerm [Syntax.VariableDeclarator]
unVariableDeclarators x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.VariableDeclarators")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unVariableReference :: Phantoms.TTerm Syntax.VariableReference -> Phantoms.TTerm Syntax.Expression
unVariableReference x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.VariableReference")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unVariantTypeParameters :: Phantoms.TTerm Syntax.VariantTypeParameters -> Phantoms.TTerm [Syntax.VariantTypeParameter]
unVariantTypeParameters x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.csharp.syntax.VariantTypeParameters")),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unaryExpressionAddressOf :: Phantoms.TTerm Syntax.UnaryExpression -> Phantoms.TTerm Syntax.UnaryExpression
unaryExpressionAddressOf x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.UnaryExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "addressOf"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

unaryExpressionAwait :: Phantoms.TTerm Syntax.UnaryExpression -> Phantoms.TTerm Syntax.UnaryExpression
unaryExpressionAwait x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.UnaryExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "await"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

unaryExpressionBitwiseComplement :: Phantoms.TTerm Syntax.UnaryExpression -> Phantoms.TTerm Syntax.UnaryExpression
unaryExpressionBitwiseComplement x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.UnaryExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "bitwiseComplement"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

unaryExpressionCast :: Phantoms.TTerm Syntax.CastExpression -> Phantoms.TTerm Syntax.UnaryExpression
unaryExpressionCast x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.UnaryExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "cast"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

unaryExpressionMinus :: Phantoms.TTerm Syntax.UnaryExpression -> Phantoms.TTerm Syntax.UnaryExpression
unaryExpressionMinus x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.UnaryExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "minus"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

unaryExpressionNot :: Phantoms.TTerm Syntax.UnaryExpression -> Phantoms.TTerm Syntax.UnaryExpression
unaryExpressionNot x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.UnaryExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "not"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

unaryExpressionPlus :: Phantoms.TTerm Syntax.UnaryExpression -> Phantoms.TTerm Syntax.UnaryExpression
unaryExpressionPlus x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.UnaryExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "plus"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

unaryExpressionPointerIndirection :: Phantoms.TTerm Syntax.UnaryExpression -> Phantoms.TTerm Syntax.UnaryExpression
unaryExpressionPointerIndirection x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.UnaryExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "pointerIndirection"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

unaryExpressionPreDecrement :: Phantoms.TTerm Syntax.UnaryExpression -> Phantoms.TTerm Syntax.UnaryExpression
unaryExpressionPreDecrement x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.UnaryExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "preDecrement"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

unaryExpressionPreIncrement :: Phantoms.TTerm Syntax.UnaryExpression -> Phantoms.TTerm Syntax.UnaryExpression
unaryExpressionPreIncrement x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.UnaryExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "preIncrement"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

unaryExpressionPrimary :: Phantoms.TTerm Syntax.PrimaryExpression -> Phantoms.TTerm Syntax.UnaryExpression
unaryExpressionPrimary x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.UnaryExpression"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "primary"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

unaryOperatorDeclarator :: Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.OverloadableUnaryOperator -> Phantoms.TTerm Syntax.FixedParameter -> Phantoms.TTerm Syntax.UnaryOperatorDeclarator
unaryOperatorDeclarator type_ operator parameter =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.UnaryOperatorDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Phantoms.unTTerm operator)},
        Core.Field {
          Core.fieldName = (Core.Name "parameter"),
          Core.fieldTerm = (Phantoms.unTTerm parameter)}]}))

unaryOperatorDeclaratorOperator :: Phantoms.TTerm Syntax.UnaryOperatorDeclarator -> Phantoms.TTerm Syntax.OverloadableUnaryOperator
unaryOperatorDeclaratorOperator x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.UnaryOperatorDeclarator"),
        Core.projectionField = (Core.Name "operator")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unaryOperatorDeclaratorParameter :: Phantoms.TTerm Syntax.UnaryOperatorDeclarator -> Phantoms.TTerm Syntax.FixedParameter
unaryOperatorDeclaratorParameter x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.UnaryOperatorDeclarator"),
        Core.projectionField = (Core.Name "parameter")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unaryOperatorDeclaratorType :: Phantoms.TTerm Syntax.UnaryOperatorDeclarator -> Phantoms.TTerm Syntax.Type
unaryOperatorDeclaratorType x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.UnaryOperatorDeclarator"),
        Core.projectionField = (Core.Name "type")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unaryOperatorDeclaratorWithOperator :: Phantoms.TTerm Syntax.UnaryOperatorDeclarator -> Phantoms.TTerm Syntax.OverloadableUnaryOperator -> Phantoms.TTerm Syntax.UnaryOperatorDeclarator
unaryOperatorDeclaratorWithOperator original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.UnaryOperatorDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.UnaryOperatorDeclarator"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "parameter"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.UnaryOperatorDeclarator"),
              Core.projectionField = (Core.Name "parameter")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

unaryOperatorDeclaratorWithParameter :: Phantoms.TTerm Syntax.UnaryOperatorDeclarator -> Phantoms.TTerm Syntax.FixedParameter -> Phantoms.TTerm Syntax.UnaryOperatorDeclarator
unaryOperatorDeclaratorWithParameter original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.UnaryOperatorDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.UnaryOperatorDeclarator"),
              Core.projectionField = (Core.Name "type")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.UnaryOperatorDeclarator"),
              Core.projectionField = (Core.Name "operator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameter"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

unaryOperatorDeclaratorWithType :: Phantoms.TTerm Syntax.UnaryOperatorDeclarator -> Phantoms.TTerm Syntax.Type -> Phantoms.TTerm Syntax.UnaryOperatorDeclarator
unaryOperatorDeclaratorWithType original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.UnaryOperatorDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "operator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.UnaryOperatorDeclarator"),
              Core.projectionField = (Core.Name "operator")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameter"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.UnaryOperatorDeclarator"),
              Core.projectionField = (Core.Name "parameter")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

unboundTypeName :: Phantoms.TTerm [Syntax.UnboundTypeNamePart] -> Phantoms.TTerm Syntax.UnboundTypeName
unboundTypeName x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.UnboundTypeName"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

unboundTypeNamePart :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Bool -> Phantoms.TTerm (Maybe Int) -> Phantoms.TTerm Syntax.UnboundTypeNamePart
unboundTypeNamePart identifier aliased dimension =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.UnboundTypeNamePart"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm identifier)},
        Core.Field {
          Core.fieldName = (Core.Name "aliased"),
          Core.fieldTerm = (Phantoms.unTTerm aliased)},
        Core.Field {
          Core.fieldName = (Core.Name "dimension"),
          Core.fieldTerm = (Phantoms.unTTerm dimension)}]}))

unboundTypeNamePartAliased :: Phantoms.TTerm Syntax.UnboundTypeNamePart -> Phantoms.TTerm Bool
unboundTypeNamePartAliased x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.UnboundTypeNamePart"),
        Core.projectionField = (Core.Name "aliased")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unboundTypeNamePartDimension :: Phantoms.TTerm Syntax.UnboundTypeNamePart -> Phantoms.TTerm (Maybe Int)
unboundTypeNamePartDimension x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.UnboundTypeNamePart"),
        Core.projectionField = (Core.Name "dimension")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unboundTypeNamePartIdentifier :: Phantoms.TTerm Syntax.UnboundTypeNamePart -> Phantoms.TTerm Syntax.Identifier
unboundTypeNamePartIdentifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.UnboundTypeNamePart"),
        Core.projectionField = (Core.Name "identifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

unboundTypeNamePartWithAliased :: Phantoms.TTerm Syntax.UnboundTypeNamePart -> Phantoms.TTerm Bool -> Phantoms.TTerm Syntax.UnboundTypeNamePart
unboundTypeNamePartWithAliased original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.UnboundTypeNamePart"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.UnboundTypeNamePart"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "aliased"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "dimension"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.UnboundTypeNamePart"),
              Core.projectionField = (Core.Name "dimension")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

unboundTypeNamePartWithDimension :: Phantoms.TTerm Syntax.UnboundTypeNamePart -> Phantoms.TTerm (Maybe Int) -> Phantoms.TTerm Syntax.UnboundTypeNamePart
unboundTypeNamePartWithDimension original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.UnboundTypeNamePart"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.UnboundTypeNamePart"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "aliased"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.UnboundTypeNamePart"),
              Core.projectionField = (Core.Name "aliased")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "dimension"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

unboundTypeNamePartWithIdentifier :: Phantoms.TTerm Syntax.UnboundTypeNamePart -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.UnboundTypeNamePart
unboundTypeNamePartWithIdentifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.UnboundTypeNamePart"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "aliased"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.UnboundTypeNamePart"),
              Core.projectionField = (Core.Name "aliased")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "dimension"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.UnboundTypeNamePart"),
              Core.projectionField = (Core.Name "dimension")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

unmanagedTypePointer :: Phantoms.TTerm Syntax.PointerType -> Phantoms.TTerm Syntax.UnmanagedType
unmanagedTypePointer x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.UnmanagedType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "pointer"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

unmanagedTypeValue :: Phantoms.TTerm Syntax.ValueType -> Phantoms.TTerm Syntax.UnmanagedType
unmanagedTypeValue x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.UnmanagedType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "value"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

usingAliasDirective :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.NamespaceOrTypeName -> Phantoms.TTerm Syntax.UsingAliasDirective
usingAliasDirective alias name =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.UsingAliasDirective"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "alias"),
          Core.fieldTerm = (Phantoms.unTTerm alias)},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm name)}]}))

usingAliasDirectiveAlias :: Phantoms.TTerm Syntax.UsingAliasDirective -> Phantoms.TTerm Syntax.Identifier
usingAliasDirectiveAlias x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.UsingAliasDirective"),
        Core.projectionField = (Core.Name "alias")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

usingAliasDirectiveName :: Phantoms.TTerm Syntax.UsingAliasDirective -> Phantoms.TTerm Syntax.NamespaceOrTypeName
usingAliasDirectiveName x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.UsingAliasDirective"),
        Core.projectionField = (Core.Name "name")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

usingAliasDirectiveWithAlias :: Phantoms.TTerm Syntax.UsingAliasDirective -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.UsingAliasDirective
usingAliasDirectiveWithAlias original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.UsingAliasDirective"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "alias"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.UsingAliasDirective"),
              Core.projectionField = (Core.Name "name")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

usingAliasDirectiveWithName :: Phantoms.TTerm Syntax.UsingAliasDirective -> Phantoms.TTerm Syntax.NamespaceOrTypeName -> Phantoms.TTerm Syntax.UsingAliasDirective
usingAliasDirectiveWithName original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.UsingAliasDirective"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "alias"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.UsingAliasDirective"),
              Core.projectionField = (Core.Name "alias")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

usingDirectiveAlias :: Phantoms.TTerm Syntax.UsingAliasDirective -> Phantoms.TTerm Syntax.UsingDirective
usingDirectiveAlias x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.UsingDirective"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "alias"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

usingDirectiveNamespace :: Phantoms.TTerm Syntax.NamespaceName -> Phantoms.TTerm Syntax.UsingDirective
usingDirectiveNamespace x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.UsingDirective"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "namespace"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

usingDirectiveStatic :: Phantoms.TTerm Syntax.TypeName -> Phantoms.TTerm Syntax.UsingDirective
usingDirectiveStatic x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.UsingDirective"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "static"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

usingStatement :: Phantoms.TTerm Syntax.ResourceAcquisition -> Phantoms.TTerm Syntax.EmbeddedStatement -> Phantoms.TTerm Syntax.UsingStatement
usingStatement acquisition body =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.UsingStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "acquisition"),
          Core.fieldTerm = (Phantoms.unTTerm acquisition)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)}]}))

usingStatementAcquisition :: Phantoms.TTerm Syntax.UsingStatement -> Phantoms.TTerm Syntax.ResourceAcquisition
usingStatementAcquisition x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.UsingStatement"),
        Core.projectionField = (Core.Name "acquisition")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

usingStatementBody :: Phantoms.TTerm Syntax.UsingStatement -> Phantoms.TTerm Syntax.EmbeddedStatement
usingStatementBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.UsingStatement"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

usingStatementWithAcquisition :: Phantoms.TTerm Syntax.UsingStatement -> Phantoms.TTerm Syntax.ResourceAcquisition -> Phantoms.TTerm Syntax.UsingStatement
usingStatementWithAcquisition original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.UsingStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "acquisition"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.UsingStatement"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

usingStatementWithBody :: Phantoms.TTerm Syntax.UsingStatement -> Phantoms.TTerm Syntax.EmbeddedStatement -> Phantoms.TTerm Syntax.UsingStatement
usingStatementWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.UsingStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "acquisition"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.UsingStatement"),
              Core.projectionField = (Core.Name "acquisition")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

valueTypeNonNullable :: Phantoms.TTerm Syntax.StructOrEnumType -> Phantoms.TTerm Syntax.ValueType
valueTypeNonNullable x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ValueType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "nonNullable"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

valueTypeNullable :: Phantoms.TTerm Syntax.StructOrEnumType -> Phantoms.TTerm Syntax.ValueType
valueTypeNullable x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.ValueType"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "nullable"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

variableDeclarator :: Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm (Maybe Syntax.VariableInitializer) -> Phantoms.TTerm Syntax.VariableDeclarator
variableDeclarator identifier initializer =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.VariableDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm identifier)},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Phantoms.unTTerm initializer)}]}))

variableDeclaratorIdentifier :: Phantoms.TTerm Syntax.VariableDeclarator -> Phantoms.TTerm Syntax.Identifier
variableDeclaratorIdentifier x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.VariableDeclarator"),
        Core.projectionField = (Core.Name "identifier")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

variableDeclaratorInitializer :: Phantoms.TTerm Syntax.VariableDeclarator -> Phantoms.TTerm (Maybe Syntax.VariableInitializer)
variableDeclaratorInitializer x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.VariableDeclarator"),
        Core.projectionField = (Core.Name "initializer")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

variableDeclaratorWithIdentifier :: Phantoms.TTerm Syntax.VariableDeclarator -> Phantoms.TTerm Syntax.Identifier -> Phantoms.TTerm Syntax.VariableDeclarator
variableDeclaratorWithIdentifier original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.VariableDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.VariableDeclarator"),
              Core.projectionField = (Core.Name "initializer")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

variableDeclaratorWithInitializer :: Phantoms.TTerm Syntax.VariableDeclarator -> Phantoms.TTerm (Maybe Syntax.VariableInitializer) -> Phantoms.TTerm Syntax.VariableDeclarator
variableDeclaratorWithInitializer original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.VariableDeclarator"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "identifier"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.VariableDeclarator"),
              Core.projectionField = (Core.Name "identifier")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "initializer"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

variableDeclarators :: Phantoms.TTerm [Syntax.VariableDeclarator] -> Phantoms.TTerm Syntax.VariableDeclarators
variableDeclarators x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.VariableDeclarators"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

variableInitializerArray :: Phantoms.TTerm Syntax.ArrayInitializer -> Phantoms.TTerm Syntax.VariableInitializer
variableInitializerArray x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.VariableInitializer"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "array"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

variableInitializerExpression :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.VariableInitializer
variableInitializerExpression x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.VariableInitializer"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "expression"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))

variableReference :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.VariableReference
variableReference x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.VariableReference"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

varianceAnnotationIn :: Phantoms.TTerm Syntax.VarianceAnnotation
varianceAnnotationIn =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.VarianceAnnotation"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "in"),
        Core.fieldTerm = Core.TermUnit}}))

varianceAnnotationOut :: Phantoms.TTerm Syntax.VarianceAnnotation
varianceAnnotationOut =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.VarianceAnnotation"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "out"),
        Core.fieldTerm = Core.TermUnit}}))

variantTypeParameter :: Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm (Maybe Syntax.VarianceAnnotation) -> Phantoms.TTerm Syntax.TypeParameter -> Phantoms.TTerm Syntax.VariantTypeParameter
variantTypeParameter attributes variance parameter =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.VariantTypeParameter"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm attributes)},
        Core.Field {
          Core.fieldName = (Core.Name "variance"),
          Core.fieldTerm = (Phantoms.unTTerm variance)},
        Core.Field {
          Core.fieldName = (Core.Name "parameter"),
          Core.fieldTerm = (Phantoms.unTTerm parameter)}]}))

variantTypeParameterAttributes :: Phantoms.TTerm Syntax.VariantTypeParameter -> Phantoms.TTerm (Maybe Syntax.Attributes)
variantTypeParameterAttributes x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.VariantTypeParameter"),
        Core.projectionField = (Core.Name "attributes")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

variantTypeParameterParameter :: Phantoms.TTerm Syntax.VariantTypeParameter -> Phantoms.TTerm Syntax.TypeParameter
variantTypeParameterParameter x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.VariantTypeParameter"),
        Core.projectionField = (Core.Name "parameter")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

variantTypeParameterVariance :: Phantoms.TTerm Syntax.VariantTypeParameter -> Phantoms.TTerm (Maybe Syntax.VarianceAnnotation)
variantTypeParameterVariance x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.VariantTypeParameter"),
        Core.projectionField = (Core.Name "variance")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

variantTypeParameterWithAttributes :: Phantoms.TTerm Syntax.VariantTypeParameter -> Phantoms.TTerm (Maybe Syntax.Attributes) -> Phantoms.TTerm Syntax.VariantTypeParameter
variantTypeParameterWithAttributes original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.VariantTypeParameter"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "variance"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.VariantTypeParameter"),
              Core.projectionField = (Core.Name "variance")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameter"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.VariantTypeParameter"),
              Core.projectionField = (Core.Name "parameter")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

variantTypeParameterWithParameter :: Phantoms.TTerm Syntax.VariantTypeParameter -> Phantoms.TTerm Syntax.TypeParameter -> Phantoms.TTerm Syntax.VariantTypeParameter
variantTypeParameterWithParameter original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.VariantTypeParameter"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.VariantTypeParameter"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "variance"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.VariantTypeParameter"),
              Core.projectionField = (Core.Name "variance")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "parameter"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

variantTypeParameterWithVariance :: Phantoms.TTerm Syntax.VariantTypeParameter -> Phantoms.TTerm (Maybe Syntax.VarianceAnnotation) -> Phantoms.TTerm Syntax.VariantTypeParameter
variantTypeParameterWithVariance original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.VariantTypeParameter"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "attributes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.VariantTypeParameter"),
              Core.projectionField = (Core.Name "attributes")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "variance"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "parameter"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.VariantTypeParameter"),
              Core.projectionField = (Core.Name "parameter")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

variantTypeParameters :: Phantoms.TTerm [Syntax.VariantTypeParameter] -> Phantoms.TTerm Syntax.VariantTypeParameters
variantTypeParameters x =
    Phantoms.TTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.csharp.syntax.VariantTypeParameters"),
      Core.wrappedTermBody = (Phantoms.unTTerm x)}))

verbatimInterpolation :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm (Maybe Syntax.ConstantExpression) -> Phantoms.TTerm (Maybe String) -> Phantoms.TTerm Syntax.VerbatimInterpolation
verbatimInterpolation expression width format =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.VerbatimInterpolation"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm expression)},
        Core.Field {
          Core.fieldName = (Core.Name "width"),
          Core.fieldTerm = (Phantoms.unTTerm width)},
        Core.Field {
          Core.fieldName = (Core.Name "format"),
          Core.fieldTerm = (Phantoms.unTTerm format)}]}))

verbatimInterpolationExpression :: Phantoms.TTerm Syntax.VerbatimInterpolation -> Phantoms.TTerm Syntax.Expression
verbatimInterpolationExpression x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.VerbatimInterpolation"),
        Core.projectionField = (Core.Name "expression")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

verbatimInterpolationFormat :: Phantoms.TTerm Syntax.VerbatimInterpolation -> Phantoms.TTerm (Maybe String)
verbatimInterpolationFormat x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.VerbatimInterpolation"),
        Core.projectionField = (Core.Name "format")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

verbatimInterpolationWidth :: Phantoms.TTerm Syntax.VerbatimInterpolation -> Phantoms.TTerm (Maybe Syntax.ConstantExpression)
verbatimInterpolationWidth x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.VerbatimInterpolation"),
        Core.projectionField = (Core.Name "width")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

verbatimInterpolationWithExpression :: Phantoms.TTerm Syntax.VerbatimInterpolation -> Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.VerbatimInterpolation
verbatimInterpolationWithExpression original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.VerbatimInterpolation"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "width"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.VerbatimInterpolation"),
              Core.projectionField = (Core.Name "width")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "format"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.VerbatimInterpolation"),
              Core.projectionField = (Core.Name "format")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

verbatimInterpolationWithFormat :: Phantoms.TTerm Syntax.VerbatimInterpolation -> Phantoms.TTerm (Maybe String) -> Phantoms.TTerm Syntax.VerbatimInterpolation
verbatimInterpolationWithFormat original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.VerbatimInterpolation"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.VerbatimInterpolation"),
              Core.projectionField = (Core.Name "expression")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "width"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.VerbatimInterpolation"),
              Core.projectionField = (Core.Name "width")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "format"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

verbatimInterpolationWithWidth :: Phantoms.TTerm Syntax.VerbatimInterpolation -> Phantoms.TTerm (Maybe Syntax.ConstantExpression) -> Phantoms.TTerm Syntax.VerbatimInterpolation
verbatimInterpolationWithWidth original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.VerbatimInterpolation"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "expression"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.VerbatimInterpolation"),
              Core.projectionField = (Core.Name "expression")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "width"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "format"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.VerbatimInterpolation"),
              Core.projectionField = (Core.Name "format")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

whileStatement :: Phantoms.TTerm Syntax.BooleanExpression -> Phantoms.TTerm Syntax.EmbeddedStatement -> Phantoms.TTerm Syntax.WhileStatement
whileStatement condition body =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.WhileStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "condition"),
          Core.fieldTerm = (Phantoms.unTTerm condition)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm body)}]}))

whileStatementBody :: Phantoms.TTerm Syntax.WhileStatement -> Phantoms.TTerm Syntax.EmbeddedStatement
whileStatementBody x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.WhileStatement"),
        Core.projectionField = (Core.Name "body")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

whileStatementCondition :: Phantoms.TTerm Syntax.WhileStatement -> Phantoms.TTerm Syntax.BooleanExpression
whileStatementCondition x =
    Phantoms.TTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.WhileStatement"),
        Core.projectionField = (Core.Name "condition")})),
      Core.applicationArgument = (Phantoms.unTTerm x)}))

whileStatementWithBody :: Phantoms.TTerm Syntax.WhileStatement -> Phantoms.TTerm Syntax.EmbeddedStatement -> Phantoms.TTerm Syntax.WhileStatement
whileStatementWithBody original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.WhileStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "condition"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.WhileStatement"),
              Core.projectionField = (Core.Name "condition")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)}]}))

whileStatementWithCondition :: Phantoms.TTerm Syntax.WhileStatement -> Phantoms.TTerm Syntax.BooleanExpression -> Phantoms.TTerm Syntax.WhileStatement
whileStatementWithCondition original newVal =
    Phantoms.TTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.csharp.syntax.WhileStatement"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "condition"),
          Core.fieldTerm = (Phantoms.unTTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "body"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.csharp.syntax.WhileStatement"),
              Core.projectionField = (Core.Name "body")})),
            Core.applicationArgument = (Phantoms.unTTerm original)}))}]}))

yieldStatementBreak :: Phantoms.TTerm Syntax.YieldStatement
yieldStatementBreak =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.YieldStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "break"),
        Core.fieldTerm = Core.TermUnit}}))

yieldStatementReturn :: Phantoms.TTerm Syntax.Expression -> Phantoms.TTerm Syntax.YieldStatement
yieldStatementReturn x =
    Phantoms.TTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.csharp.syntax.YieldStatement"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "return"),
        Core.fieldTerm = (Phantoms.unTTerm x)}}))