hydra-kernel-0.17.7: src/main/haskell/Hydra/Dsl/Paths.hs

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

-- | DSL functions for hydra.paths

module Hydra.Dsl.Paths where

import qualified Hydra.Core as Core
import qualified Hydra.Decode.Paths as DecodePaths
import qualified Hydra.Dsl.Core as DslCore
import qualified Hydra.Encode.Paths as EncodePaths
import qualified Hydra.Paths as Paths
import qualified Hydra.Typed as Typed
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
import qualified Data.Scientific as Sci
import Data.Void
import qualified Data.Map as M

-- | DSL constructor for hydra.paths.LambdaVariableReference
lambdaVariableReference :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermNodeId -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Paths.LambdaVariableReference
lambdaVariableReference variable boundByNode type_ =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.LambdaVariableReference"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "variable"),
          Core.fieldTerm = (Typed.unTypedTerm variable)},
        Core.Field {
          Core.fieldName = (Core.Name "boundByNode"),
          Core.fieldTerm = (Typed.unTypedTerm boundByNode)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Typed.unTypedTerm type_)}]}))

-- | DSL accessor for the boundByNode field of hydra.paths.LambdaVariableReference
lambdaVariableReferenceBoundByNode :: Typed.TypedTerm Paths.LambdaVariableReference -> Typed.TypedTerm Paths.TermNodeId
lambdaVariableReferenceBoundByNode x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.paths.LambdaVariableReference"),
        Core.projectionFieldName = (Core.Name "boundByNode")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.paths.LambdaVariableReference
lambdaVariableReferenceLambdaVariableReference :: Typed.TypedName Paths.LambdaVariableReference
lambdaVariableReferenceLambdaVariableReference = Typed.TypedName (Core.Name "hydra.paths.LambdaVariableReference")

-- | DSL accessor for the type field of hydra.paths.LambdaVariableReference
lambdaVariableReferenceType :: Typed.TypedTerm Paths.LambdaVariableReference -> Typed.TypedTerm Core.Type
lambdaVariableReferenceType x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.paths.LambdaVariableReference"),
        Core.projectionFieldName = (Core.Name "type")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the variable field of hydra.paths.LambdaVariableReference
lambdaVariableReferenceVariable :: Typed.TypedTerm Paths.LambdaVariableReference -> Typed.TypedTerm Core.Name
lambdaVariableReferenceVariable x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.paths.LambdaVariableReference"),
        Core.projectionFieldName = (Core.Name "variable")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the boundByNode field of hydra.paths.LambdaVariableReference
lambdaVariableReferenceWithBoundByNode :: Typed.TypedTerm Paths.LambdaVariableReference -> Typed.TypedTerm Paths.TermNodeId -> Typed.TypedTerm Paths.LambdaVariableReference
lambdaVariableReferenceWithBoundByNode original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.LambdaVariableReference"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "variable"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.paths.LambdaVariableReference"),
              Core.projectionFieldName = (Core.Name "variable")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "boundByNode"),
          Core.fieldTerm = (Typed.unTypedTerm 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.paths.LambdaVariableReference"),
              Core.projectionFieldName = (Core.Name "type")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.paths.LambdaVariableReference
lambdaVariableReferenceWithType :: Typed.TypedTerm Paths.LambdaVariableReference -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Paths.LambdaVariableReference
lambdaVariableReferenceWithType original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.LambdaVariableReference"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "variable"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.paths.LambdaVariableReference"),
              Core.projectionFieldName = (Core.Name "variable")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "boundByNode"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.paths.LambdaVariableReference"),
              Core.projectionFieldName = (Core.Name "boundByNode")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the variable field of hydra.paths.LambdaVariableReference
lambdaVariableReferenceWithVariable :: Typed.TypedTerm Paths.LambdaVariableReference -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.LambdaVariableReference
lambdaVariableReferenceWithVariable original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.LambdaVariableReference"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "variable"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "boundByNode"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.paths.LambdaVariableReference"),
              Core.projectionFieldName = (Core.Name "boundByNode")})),
            Core.applicationArgument = (Typed.unTypedTerm 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.paths.LambdaVariableReference"),
              Core.projectionFieldName = (Core.Name "type")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.paths.LetVariableReference
letVariableReference :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermNodeId -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Paths.LetVariableReference
letVariableReference variable bindingNode type_ =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.LetVariableReference"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "variable"),
          Core.fieldTerm = (Typed.unTypedTerm variable)},
        Core.Field {
          Core.fieldName = (Core.Name "bindingNode"),
          Core.fieldTerm = (Typed.unTypedTerm bindingNode)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Typed.unTypedTerm type_)}]}))

-- | DSL accessor for the bindingNode field of hydra.paths.LetVariableReference
letVariableReferenceBindingNode :: Typed.TypedTerm Paths.LetVariableReference -> Typed.TypedTerm Paths.TermNodeId
letVariableReferenceBindingNode x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.paths.LetVariableReference"),
        Core.projectionFieldName = (Core.Name "bindingNode")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.paths.LetVariableReference
letVariableReferenceLetVariableReference :: Typed.TypedName Paths.LetVariableReference
letVariableReferenceLetVariableReference = Typed.TypedName (Core.Name "hydra.paths.LetVariableReference")

-- | DSL accessor for the type field of hydra.paths.LetVariableReference
letVariableReferenceType :: Typed.TypedTerm Paths.LetVariableReference -> Typed.TypedTerm Core.Type
letVariableReferenceType x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.paths.LetVariableReference"),
        Core.projectionFieldName = (Core.Name "type")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the variable field of hydra.paths.LetVariableReference
letVariableReferenceVariable :: Typed.TypedTerm Paths.LetVariableReference -> Typed.TypedTerm Core.Name
letVariableReferenceVariable x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.paths.LetVariableReference"),
        Core.projectionFieldName = (Core.Name "variable")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the bindingNode field of hydra.paths.LetVariableReference
letVariableReferenceWithBindingNode :: Typed.TypedTerm Paths.LetVariableReference -> Typed.TypedTerm Paths.TermNodeId -> Typed.TypedTerm Paths.LetVariableReference
letVariableReferenceWithBindingNode original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.LetVariableReference"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "variable"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.paths.LetVariableReference"),
              Core.projectionFieldName = (Core.Name "variable")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "bindingNode"),
          Core.fieldTerm = (Typed.unTypedTerm 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.paths.LetVariableReference"),
              Core.projectionFieldName = (Core.Name "type")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.paths.LetVariableReference
letVariableReferenceWithType :: Typed.TypedTerm Paths.LetVariableReference -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Paths.LetVariableReference
letVariableReferenceWithType original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.LetVariableReference"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "variable"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.paths.LetVariableReference"),
              Core.projectionFieldName = (Core.Name "variable")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "bindingNode"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.paths.LetVariableReference"),
              Core.projectionFieldName = (Core.Name "bindingNode")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the variable field of hydra.paths.LetVariableReference
letVariableReferenceWithVariable :: Typed.TypedTerm Paths.LetVariableReference -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.LetVariableReference
letVariableReferenceWithVariable original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.LetVariableReference"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "variable"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "bindingNode"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.paths.LetVariableReference"),
              Core.projectionFieldName = (Core.Name "bindingNode")})),
            Core.applicationArgument = (Typed.unTypedTerm 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.paths.LetVariableReference"),
              Core.projectionFieldName = (Core.Name "type")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.paths.NominalTypeReference
nominalTypeReference :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.NominalTypeReference
nominalTypeReference name =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.NominalTypeReference"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Typed.unTypedTerm name)}]}))

-- | DSL accessor for the name field of hydra.paths.NominalTypeReference
nominalTypeReferenceName :: Typed.TypedTerm Paths.NominalTypeReference -> Typed.TypedTerm Core.Name
nominalTypeReferenceName x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.paths.NominalTypeReference"),
        Core.projectionFieldName = (Core.Name "name")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.paths.NominalTypeReference
nominalTypeReferenceNominalTypeReference :: Typed.TypedName Paths.NominalTypeReference
nominalTypeReferenceNominalTypeReference = Typed.TypedName (Core.Name "hydra.paths.NominalTypeReference")

-- | DSL updater for the name field of hydra.paths.NominalTypeReference
nominalTypeReferenceWithName :: Typed.TypedTerm Paths.NominalTypeReference -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.NominalTypeReference
nominalTypeReferenceWithName original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.NominalTypeReference"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.paths.PrimitiveReference
primitiveReference :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Paths.PrimitiveReference
primitiveReference name type_ =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.PrimitiveReference"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Typed.unTypedTerm name)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Typed.unTypedTerm type_)}]}))

-- | DSL accessor for the name field of hydra.paths.PrimitiveReference
primitiveReferenceName :: Typed.TypedTerm Paths.PrimitiveReference -> Typed.TypedTerm Core.Name
primitiveReferenceName x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.paths.PrimitiveReference"),
        Core.projectionFieldName = (Core.Name "name")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.paths.PrimitiveReference
primitiveReferencePrimitiveReference :: Typed.TypedName Paths.PrimitiveReference
primitiveReferencePrimitiveReference = Typed.TypedName (Core.Name "hydra.paths.PrimitiveReference")

-- | DSL accessor for the type field of hydra.paths.PrimitiveReference
primitiveReferenceType :: Typed.TypedTerm Paths.PrimitiveReference -> Typed.TypedTerm Core.Type
primitiveReferenceType x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.paths.PrimitiveReference"),
        Core.projectionFieldName = (Core.Name "type")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the name field of hydra.paths.PrimitiveReference
primitiveReferenceWithName :: Typed.TypedTerm Paths.PrimitiveReference -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.PrimitiveReference
primitiveReferenceWithName original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.PrimitiveReference"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Typed.unTypedTerm 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.paths.PrimitiveReference"),
              Core.projectionFieldName = (Core.Name "type")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.paths.PrimitiveReference
primitiveReferenceWithType :: Typed.TypedTerm Paths.PrimitiveReference -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Paths.PrimitiveReference
primitiveReferenceWithType original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.PrimitiveReference"),
      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.paths.PrimitiveReference"),
              Core.projectionFieldName = (Core.Name "name")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.paths.SubtermLink
subtermLink :: Typed.TypedTerm Paths.SubtermStep -> Typed.TypedTerm Paths.TermNode -> Typed.TypedTerm Paths.SubtermLink
subtermLink step child =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.SubtermLink"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "step"),
          Core.fieldTerm = (Typed.unTypedTerm step)},
        Core.Field {
          Core.fieldName = (Core.Name "child"),
          Core.fieldTerm = (Typed.unTypedTerm child)}]}))

-- | DSL accessor for the child field of hydra.paths.SubtermLink
subtermLinkChild :: Typed.TypedTerm Paths.SubtermLink -> Typed.TypedTerm Paths.TermNode
subtermLinkChild x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.paths.SubtermLink"),
        Core.projectionFieldName = (Core.Name "child")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the step field of hydra.paths.SubtermLink
subtermLinkStep :: Typed.TypedTerm Paths.SubtermLink -> Typed.TypedTerm Paths.SubtermStep
subtermLinkStep x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.paths.SubtermLink"),
        Core.projectionFieldName = (Core.Name "step")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.paths.SubtermLink
subtermLinkSubtermLink :: Typed.TypedName Paths.SubtermLink
subtermLinkSubtermLink = Typed.TypedName (Core.Name "hydra.paths.SubtermLink")

-- | DSL updater for the child field of hydra.paths.SubtermLink
subtermLinkWithChild :: Typed.TypedTerm Paths.SubtermLink -> Typed.TypedTerm Paths.TermNode -> Typed.TypedTerm Paths.SubtermLink
subtermLinkWithChild original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.SubtermLink"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "step"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.paths.SubtermLink"),
              Core.projectionFieldName = (Core.Name "step")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "child"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the step field of hydra.paths.SubtermLink
subtermLinkWithStep :: Typed.TypedTerm Paths.SubtermLink -> Typed.TypedTerm Paths.SubtermStep -> Typed.TypedTerm Paths.SubtermLink
subtermLinkWithStep original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.SubtermLink"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "step"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "child"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.paths.SubtermLink"),
              Core.projectionFieldName = (Core.Name "child")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for the hydra.paths.SubtermPath wrapper
subtermPath :: Typed.TypedTerm [Paths.SubtermStep] -> Typed.TypedTerm Paths.SubtermPath
subtermPath x =
    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.paths.SubtermPath"),
      Core.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.paths.SubtermPath
subtermPathSubtermPath :: Typed.TypedName Paths.SubtermPath
subtermPathSubtermPath = Typed.TypedName (Core.Name "hydra.paths.SubtermPath")

-- | DSL injection for the annotatedAnnotation variant of hydra.paths.SubtermStep
subtermStepAnnotatedAnnotation :: Typed.TypedTerm Paths.SubtermStep
subtermStepAnnotatedAnnotation =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "annotatedAnnotation"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the annotatedBody variant of hydra.paths.SubtermStep
subtermStepAnnotatedBody :: Typed.TypedTerm Paths.SubtermStep
subtermStepAnnotatedBody =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "annotatedBody"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the applicationArgument variant of hydra.paths.SubtermStep
subtermStepApplicationArgument :: Typed.TypedTerm Paths.SubtermStep
subtermStepApplicationArgument =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "applicationArgument"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the applicationFunction variant of hydra.paths.SubtermStep
subtermStepApplicationFunction :: Typed.TypedTerm Paths.SubtermStep
subtermStepApplicationFunction =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "applicationFunction"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the casesCase variant of hydra.paths.SubtermStep
subtermStepCasesCase :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtermStep
subtermStepCasesCase x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "casesCase"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the casesDefault variant of hydra.paths.SubtermStep
subtermStepCasesDefault :: Typed.TypedTerm Paths.SubtermStep
subtermStepCasesDefault =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "casesDefault"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the eitherLeft variant of hydra.paths.SubtermStep
subtermStepEitherLeft :: Typed.TypedTerm Paths.SubtermStep
subtermStepEitherLeft =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "eitherLeft"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the eitherRight variant of hydra.paths.SubtermStep
subtermStepEitherRight :: Typed.TypedTerm Paths.SubtermStep
subtermStepEitherRight =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "eitherRight"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the injectField variant of hydra.paths.SubtermStep
subtermStepInjectField :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtermStep
subtermStepInjectField x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "injectField"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the lambdaBody variant of hydra.paths.SubtermStep
subtermStepLambdaBody :: Typed.TypedTerm Paths.SubtermStep
subtermStepLambdaBody =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "lambdaBody"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the letBinding variant of hydra.paths.SubtermStep
subtermStepLetBinding :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtermStep
subtermStepLetBinding x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "letBinding"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the letBody variant of hydra.paths.SubtermStep
subtermStepLetBody :: Typed.TypedTerm Paths.SubtermStep
subtermStepLetBody =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "letBody"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the listElement variant of hydra.paths.SubtermStep
subtermStepListElement :: Typed.TypedTerm Int -> Typed.TypedTerm Paths.SubtermStep
subtermStepListElement x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "listElement"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the mapEntry variant of hydra.paths.SubtermStep
subtermStepMapEntry :: Typed.TypedTerm Int -> Typed.TypedTerm Paths.SubtermStep
subtermStepMapEntry x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "mapEntry"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the optionalGiven variant of hydra.paths.SubtermStep
subtermStepOptionalGiven :: Typed.TypedTerm Paths.SubtermStep
subtermStepOptionalGiven =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "optionalGiven"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the pairFirst variant of hydra.paths.SubtermStep
subtermStepPairFirst :: Typed.TypedTerm Paths.SubtermStep
subtermStepPairFirst =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "pairFirst"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the pairSecond variant of hydra.paths.SubtermStep
subtermStepPairSecond :: Typed.TypedTerm Paths.SubtermStep
subtermStepPairSecond =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "pairSecond"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the recordField variant of hydra.paths.SubtermStep
subtermStepRecordField :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtermStep
subtermStepRecordField x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "recordField"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the setElement variant of hydra.paths.SubtermStep
subtermStepSetElement :: Typed.TypedTerm Int -> Typed.TypedTerm Paths.SubtermStep
subtermStepSetElement x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "setElement"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.paths.SubtermStep
subtermStepSubtermStep :: Typed.TypedName Paths.SubtermStep
subtermStepSubtermStep = Typed.TypedName (Core.Name "hydra.paths.SubtermStep")

-- | DSL injection for the typeApplicationBody variant of hydra.paths.SubtermStep
subtermStepTypeApplicationBody :: Typed.TypedTerm Paths.SubtermStep
subtermStepTypeApplicationBody =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "typeApplicationBody"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the typeLambdaBody variant of hydra.paths.SubtermStep
subtermStepTypeLambdaBody :: Typed.TypedTerm Paths.SubtermStep
subtermStepTypeLambdaBody =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "typeLambdaBody"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the wrapBody variant of hydra.paths.SubtermStep
subtermStepWrapBody :: Typed.TypedTerm Paths.SubtermStep
subtermStepWrapBody =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "wrapBody"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL constructor for hydra.paths.SubtypeLink
subtypeLink :: Typed.TypedTerm Paths.SubtypeStep -> Typed.TypedTerm Paths.TypeNode -> Typed.TypedTerm Paths.SubtypeLink
subtypeLink step child =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeLink"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "step"),
          Core.fieldTerm = (Typed.unTypedTerm step)},
        Core.Field {
          Core.fieldName = (Core.Name "child"),
          Core.fieldTerm = (Typed.unTypedTerm child)}]}))

-- | DSL accessor for the child field of hydra.paths.SubtypeLink
subtypeLinkChild :: Typed.TypedTerm Paths.SubtypeLink -> Typed.TypedTerm Paths.TypeNode
subtypeLinkChild x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeLink"),
        Core.projectionFieldName = (Core.Name "child")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the step field of hydra.paths.SubtypeLink
subtypeLinkStep :: Typed.TypedTerm Paths.SubtypeLink -> Typed.TypedTerm Paths.SubtypeStep
subtypeLinkStep x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeLink"),
        Core.projectionFieldName = (Core.Name "step")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.paths.SubtypeLink
subtypeLinkSubtypeLink :: Typed.TypedName Paths.SubtypeLink
subtypeLinkSubtypeLink = Typed.TypedName (Core.Name "hydra.paths.SubtypeLink")

-- | DSL updater for the child field of hydra.paths.SubtypeLink
subtypeLinkWithChild :: Typed.TypedTerm Paths.SubtypeLink -> Typed.TypedTerm Paths.TypeNode -> Typed.TypedTerm Paths.SubtypeLink
subtypeLinkWithChild original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeLink"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "step"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeLink"),
              Core.projectionFieldName = (Core.Name "step")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "child"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the step field of hydra.paths.SubtypeLink
subtypeLinkWithStep :: Typed.TypedTerm Paths.SubtypeLink -> Typed.TypedTerm Paths.SubtypeStep -> Typed.TypedTerm Paths.SubtypeLink
subtypeLinkWithStep original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeLink"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "step"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "child"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeLink"),
              Core.projectionFieldName = (Core.Name "child")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for the hydra.paths.SubtypePath wrapper
subtypePath :: Typed.TypedTerm [Paths.SubtypeStep] -> Typed.TypedTerm Paths.SubtypePath
subtypePath x =
    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.paths.SubtypePath"),
      Core.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.paths.SubtypePath
subtypePathSubtypePath :: Typed.TypedName Paths.SubtypePath
subtypePathSubtypePath = Typed.TypedName (Core.Name "hydra.paths.SubtypePath")

-- | DSL injection for the annotatedBody variant of hydra.paths.SubtypeStep
subtypeStepAnnotatedBody :: Typed.TypedTerm Paths.SubtypeStep
subtypeStepAnnotatedBody =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "annotatedBody"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the applicationArgument variant of hydra.paths.SubtypeStep
subtypeStepApplicationArgument :: Typed.TypedTerm Paths.SubtypeStep
subtypeStepApplicationArgument =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "applicationArgument"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the applicationFunction variant of hydra.paths.SubtypeStep
subtypeStepApplicationFunction :: Typed.TypedTerm Paths.SubtypeStep
subtypeStepApplicationFunction =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "applicationFunction"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the effectValue variant of hydra.paths.SubtypeStep
subtypeStepEffectValue :: Typed.TypedTerm Paths.SubtypeStep
subtypeStepEffectValue =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "effectValue"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the eitherLeft variant of hydra.paths.SubtypeStep
subtypeStepEitherLeft :: Typed.TypedTerm Paths.SubtypeStep
subtypeStepEitherLeft =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "eitherLeft"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the eitherRight variant of hydra.paths.SubtypeStep
subtypeStepEitherRight :: Typed.TypedTerm Paths.SubtypeStep
subtypeStepEitherRight =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "eitherRight"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the forallBody variant of hydra.paths.SubtypeStep
subtypeStepForallBody :: Typed.TypedTerm Paths.SubtypeStep
subtypeStepForallBody =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "forallBody"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the functionCodomain variant of hydra.paths.SubtypeStep
subtypeStepFunctionCodomain :: Typed.TypedTerm Paths.SubtypeStep
subtypeStepFunctionCodomain =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "functionCodomain"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the functionDomain variant of hydra.paths.SubtypeStep
subtypeStepFunctionDomain :: Typed.TypedTerm Paths.SubtypeStep
subtypeStepFunctionDomain =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "functionDomain"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the listElement variant of hydra.paths.SubtypeStep
subtypeStepListElement :: Typed.TypedTerm Paths.SubtypeStep
subtypeStepListElement =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "listElement"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the mapKeys variant of hydra.paths.SubtypeStep
subtypeStepMapKeys :: Typed.TypedTerm Paths.SubtypeStep
subtypeStepMapKeys =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "mapKeys"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the mapValues variant of hydra.paths.SubtypeStep
subtypeStepMapValues :: Typed.TypedTerm Paths.SubtypeStep
subtypeStepMapValues =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "mapValues"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the optionalElement variant of hydra.paths.SubtypeStep
subtypeStepOptionalElement :: Typed.TypedTerm Paths.SubtypeStep
subtypeStepOptionalElement =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "optionalElement"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the pairFirst variant of hydra.paths.SubtypeStep
subtypeStepPairFirst :: Typed.TypedTerm Paths.SubtypeStep
subtypeStepPairFirst =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "pairFirst"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the pairSecond variant of hydra.paths.SubtypeStep
subtypeStepPairSecond :: Typed.TypedTerm Paths.SubtypeStep
subtypeStepPairSecond =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "pairSecond"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the recordField variant of hydra.paths.SubtypeStep
subtypeStepRecordField :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtypeStep
subtypeStepRecordField x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "recordField"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the setElement variant of hydra.paths.SubtypeStep
subtypeStepSetElement :: Typed.TypedTerm Paths.SubtypeStep
subtypeStepSetElement =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "setElement"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL name token for hydra.paths.SubtypeStep
subtypeStepSubtypeStep :: Typed.TypedName Paths.SubtypeStep
subtypeStepSubtypeStep = Typed.TypedName (Core.Name "hydra.paths.SubtypeStep")

-- | DSL injection for the unionField variant of hydra.paths.SubtypeStep
subtypeStepUnionField :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtypeStep
subtypeStepUnionField x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "unionField"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the wrapBody variant of hydra.paths.SubtypeStep
subtypeStepWrapBody :: Typed.TypedTerm Paths.SubtypeStep
subtypeStepWrapBody =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "wrapBody"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the casesTypeName variant of hydra.paths.TermAttributeLink
termAttributeLinkCasesTypeName :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermAttributeLink
termAttributeLinkCasesTypeName x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "casesTypeName"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the injectTypeName variant of hydra.paths.TermAttributeLink
termAttributeLinkInjectTypeName :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermAttributeLink
termAttributeLinkInjectTypeName x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "injectTypeName"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the lambdaDomainGiven variant of hydra.paths.TermAttributeLink
termAttributeLinkLambdaDomainGiven :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Paths.TermAttributeLink
termAttributeLinkLambdaDomainGiven x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "lambdaDomainGiven"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the lambdaParameter variant of hydra.paths.TermAttributeLink
termAttributeLinkLambdaParameter :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermAttributeLink
termAttributeLinkLambdaParameter x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "lambdaParameter"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the letBindingTypeSchemeGiven variant of hydra.paths.TermAttributeLink
termAttributeLinkLetBindingTypeSchemeGiven :: Typed.TypedTerm (Core.Name, Core.TypeScheme) -> Typed.TypedTerm Paths.TermAttributeLink
termAttributeLinkLetBindingTypeSchemeGiven x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "letBindingTypeSchemeGiven"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the literal variant of hydra.paths.TermAttributeLink
termAttributeLinkLiteral :: Typed.TypedTerm Core.Literal -> Typed.TypedTerm Paths.TermAttributeLink
termAttributeLinkLiteral x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "literal"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the projectFieldName variant of hydra.paths.TermAttributeLink
termAttributeLinkProjectFieldName :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermAttributeLink
termAttributeLinkProjectFieldName x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "projectFieldName"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the projectTypeName variant of hydra.paths.TermAttributeLink
termAttributeLinkProjectTypeName :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermAttributeLink
termAttributeLinkProjectTypeName x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "projectTypeName"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the recordTypeName variant of hydra.paths.TermAttributeLink
termAttributeLinkRecordTypeName :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermAttributeLink
termAttributeLinkRecordTypeName x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "recordTypeName"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.paths.TermAttributeLink
termAttributeLinkTermAttributeLink :: Typed.TypedName Paths.TermAttributeLink
termAttributeLinkTermAttributeLink = Typed.TypedName (Core.Name "hydra.paths.TermAttributeLink")

-- | DSL injection for the typeApplicationType variant of hydra.paths.TermAttributeLink
termAttributeLinkTypeApplicationType :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Paths.TermAttributeLink
termAttributeLinkTypeApplicationType x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "typeApplicationType"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the typeLambdaParameter variant of hydra.paths.TermAttributeLink
termAttributeLinkTypeLambdaParameter :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermAttributeLink
termAttributeLinkTypeLambdaParameter x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "typeLambdaParameter"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the unwrapTypeName variant of hydra.paths.TermAttributeLink
termAttributeLinkUnwrapTypeName :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermAttributeLink
termAttributeLinkUnwrapTypeName x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "unwrapTypeName"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the wrapTypeName variant of hydra.paths.TermAttributeLink
termAttributeLinkWrapTypeName :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermAttributeLink
termAttributeLinkWrapTypeName x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttributeLink"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "wrapTypeName"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.paths.TermGraph
termGraph :: Typed.TypedTerm (M.Map Core.Name Paths.TermNode) -> Typed.TypedTerm Paths.TermGraph
termGraph roots =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TermGraph"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "roots"),
          Core.fieldTerm = (Typed.unTypedTerm roots)}]}))

-- | DSL accessor for the roots field of hydra.paths.TermGraph
termGraphRoots :: Typed.TypedTerm Paths.TermGraph -> Typed.TypedTerm (M.Map Core.Name Paths.TermNode)
termGraphRoots x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.paths.TermGraph"),
        Core.projectionFieldName = (Core.Name "roots")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.paths.TermGraph
termGraphTermGraph :: Typed.TypedName Paths.TermGraph
termGraphTermGraph = Typed.TypedName (Core.Name "hydra.paths.TermGraph")

-- | DSL updater for the roots field of hydra.paths.TermGraph
termGraphWithRoots :: Typed.TypedTerm Paths.TermGraph -> Typed.TypedTerm (M.Map Core.Name Paths.TermNode) -> Typed.TypedTerm Paths.TermGraph
termGraphWithRoots original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TermGraph"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "roots"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the attribute variant of hydra.paths.TermLink
termLinkAttribute :: Typed.TypedTerm Paths.TermAttributeLink -> Typed.TypedTerm Paths.TermLink
termLinkAttribute x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.TermLink"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "attribute"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the reference variant of hydra.paths.TermLink
termLinkReference :: Typed.TypedTerm Paths.TermReferenceLink -> Typed.TypedTerm Paths.TermLink
termLinkReference x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.TermLink"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "reference"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the subterm variant of hydra.paths.TermLink
termLinkSubterm :: Typed.TypedTerm Paths.SubtermLink -> Typed.TypedTerm Paths.TermLink
termLinkSubterm x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.TermLink"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "subterm"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.paths.TermLink
termLinkTermLink :: Typed.TypedName Paths.TermLink
termLinkTermLink = Typed.TypedName (Core.Name "hydra.paths.TermLink")

-- | DSL constructor for hydra.paths.TermNode
termNode :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Type -> Typed.TypedTerm [Paths.TermLink] -> Typed.TypedTerm Paths.TermNode
termNode term type_ links =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TermNode"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "term"),
          Core.fieldTerm = (Typed.unTypedTerm term)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Typed.unTypedTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "links"),
          Core.fieldTerm = (Typed.unTypedTerm links)}]}))

-- | DSL constructor for hydra.paths.TermNodeId
termNodeId :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Paths.TermNodeId
termNodeId root path =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TermNodeId"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "root"),
          Core.fieldTerm = (Typed.unTypedTerm root)},
        Core.Field {
          Core.fieldName = (Core.Name "path"),
          Core.fieldTerm = (Typed.unTypedTerm path)}]}))

-- | DSL accessor for the path field of hydra.paths.TermNodeId
termNodeIdPath :: Typed.TypedTerm Paths.TermNodeId -> Typed.TypedTerm Paths.SubtermPath
termNodeIdPath x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.paths.TermNodeId"),
        Core.projectionFieldName = (Core.Name "path")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the root field of hydra.paths.TermNodeId
termNodeIdRoot :: Typed.TypedTerm Paths.TermNodeId -> Typed.TypedTerm Core.Name
termNodeIdRoot x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.paths.TermNodeId"),
        Core.projectionFieldName = (Core.Name "root")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.paths.TermNodeId
termNodeIdTermNodeId :: Typed.TypedName Paths.TermNodeId
termNodeIdTermNodeId = Typed.TypedName (Core.Name "hydra.paths.TermNodeId")

-- | DSL updater for the path field of hydra.paths.TermNodeId
termNodeIdWithPath :: Typed.TypedTerm Paths.TermNodeId -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Paths.TermNodeId
termNodeIdWithPath original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TermNodeId"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "root"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.paths.TermNodeId"),
              Core.projectionFieldName = (Core.Name "root")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "path"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the root field of hydra.paths.TermNodeId
termNodeIdWithRoot :: Typed.TypedTerm Paths.TermNodeId -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermNodeId
termNodeIdWithRoot original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TermNodeId"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "root"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "path"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.paths.TermNodeId"),
              Core.projectionFieldName = (Core.Name "path")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL accessor for the links field of hydra.paths.TermNode
termNodeLinks :: Typed.TypedTerm Paths.TermNode -> Typed.TypedTerm [Paths.TermLink]
termNodeLinks x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.paths.TermNode"),
        Core.projectionFieldName = (Core.Name "links")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the term field of hydra.paths.TermNode
termNodeTerm :: Typed.TypedTerm Paths.TermNode -> Typed.TypedTerm Core.Term
termNodeTerm x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.paths.TermNode"),
        Core.projectionFieldName = (Core.Name "term")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.paths.TermNode
termNodeTermNode :: Typed.TypedName Paths.TermNode
termNodeTermNode = Typed.TypedName (Core.Name "hydra.paths.TermNode")

-- | DSL accessor for the type field of hydra.paths.TermNode
termNodeType :: Typed.TypedTerm Paths.TermNode -> Typed.TypedTerm Core.Type
termNodeType x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.paths.TermNode"),
        Core.projectionFieldName = (Core.Name "type")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the links field of hydra.paths.TermNode
termNodeWithLinks :: Typed.TypedTerm Paths.TermNode -> Typed.TypedTerm [Paths.TermLink] -> Typed.TypedTerm Paths.TermNode
termNodeWithLinks original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TermNode"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "term"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.paths.TermNode"),
              Core.projectionFieldName = (Core.Name "term")})),
            Core.applicationArgument = (Typed.unTypedTerm 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.paths.TermNode"),
              Core.projectionFieldName = (Core.Name "type")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "links"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the term field of hydra.paths.TermNode
termNodeWithTerm :: Typed.TypedTerm Paths.TermNode -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Paths.TermNode
termNodeWithTerm original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TermNode"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "term"),
          Core.fieldTerm = (Typed.unTypedTerm 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.paths.TermNode"),
              Core.projectionFieldName = (Core.Name "type")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "links"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.paths.TermNode"),
              Core.projectionFieldName = (Core.Name "links")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.paths.TermNode
termNodeWithType :: Typed.TypedTerm Paths.TermNode -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Paths.TermNode
termNodeWithType original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TermNode"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "term"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.paths.TermNode"),
              Core.projectionFieldName = (Core.Name "term")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "links"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.paths.TermNode"),
              Core.projectionFieldName = (Core.Name "links")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the lambda variant of hydra.paths.TermReference
termReferenceLambda :: Typed.TypedTerm Paths.LambdaVariableReference -> Typed.TypedTerm Paths.TermReference
termReferenceLambda x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.TermReference"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "lambda"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the let variant of hydra.paths.TermReference
termReferenceLet :: Typed.TypedTerm Paths.LetVariableReference -> Typed.TypedTerm Paths.TermReference
termReferenceLet x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.TermReference"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "let"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.paths.TermReferenceLink
termReferenceLink :: Typed.TypedTerm Paths.SubtermStep -> Typed.TypedTerm Paths.TermReference -> Typed.TypedTerm Paths.TermReferenceLink
termReferenceLink step target =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TermReferenceLink"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "step"),
          Core.fieldTerm = (Typed.unTypedTerm step)},
        Core.Field {
          Core.fieldName = (Core.Name "target"),
          Core.fieldTerm = (Typed.unTypedTerm target)}]}))

-- | DSL accessor for the step field of hydra.paths.TermReferenceLink
termReferenceLinkStep :: Typed.TypedTerm Paths.TermReferenceLink -> Typed.TypedTerm Paths.SubtermStep
termReferenceLinkStep x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.paths.TermReferenceLink"),
        Core.projectionFieldName = (Core.Name "step")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the target field of hydra.paths.TermReferenceLink
termReferenceLinkTarget :: Typed.TypedTerm Paths.TermReferenceLink -> Typed.TypedTerm Paths.TermReference
termReferenceLinkTarget x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.paths.TermReferenceLink"),
        Core.projectionFieldName = (Core.Name "target")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.paths.TermReferenceLink
termReferenceLinkTermReferenceLink :: Typed.TypedName Paths.TermReferenceLink
termReferenceLinkTermReferenceLink = Typed.TypedName (Core.Name "hydra.paths.TermReferenceLink")

-- | DSL updater for the step field of hydra.paths.TermReferenceLink
termReferenceLinkWithStep :: Typed.TypedTerm Paths.TermReferenceLink -> Typed.TypedTerm Paths.SubtermStep -> Typed.TypedTerm Paths.TermReferenceLink
termReferenceLinkWithStep original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TermReferenceLink"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "step"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "target"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.paths.TermReferenceLink"),
              Core.projectionFieldName = (Core.Name "target")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the target field of hydra.paths.TermReferenceLink
termReferenceLinkWithTarget :: Typed.TypedTerm Paths.TermReferenceLink -> Typed.TypedTerm Paths.TermReference -> Typed.TypedTerm Paths.TermReferenceLink
termReferenceLinkWithTarget original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TermReferenceLink"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "step"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.paths.TermReferenceLink"),
              Core.projectionFieldName = (Core.Name "step")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "target"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the primitive variant of hydra.paths.TermReference
termReferencePrimitive :: Typed.TypedTerm Paths.PrimitiveReference -> Typed.TypedTerm Paths.TermReference
termReferencePrimitive x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.TermReference"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "primitive"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.paths.TermReference
termReferenceTermReference :: Typed.TypedName Paths.TermReference
termReferenceTermReference = Typed.TypedName (Core.Name "hydra.paths.TermReference")

-- | DSL injection for the annotatedAnnotation variant of hydra.paths.TypeAttributeLink
typeAttributeLinkAnnotatedAnnotation :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Paths.TypeAttributeLink
typeAttributeLinkAnnotatedAnnotation x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.TypeAttributeLink"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "annotatedAnnotation"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the forallParameter variant of hydra.paths.TypeAttributeLink
typeAttributeLinkForallParameter :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TypeAttributeLink
typeAttributeLinkForallParameter x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.TypeAttributeLink"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "forallParameter"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the literal variant of hydra.paths.TypeAttributeLink
typeAttributeLinkLiteral :: Typed.TypedTerm Core.LiteralType -> Typed.TypedTerm Paths.TypeAttributeLink
typeAttributeLinkLiteral x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.TypeAttributeLink"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "literal"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.paths.TypeAttributeLink
typeAttributeLinkTypeAttributeLink :: Typed.TypedName Paths.TypeAttributeLink
typeAttributeLinkTypeAttributeLink = Typed.TypedName (Core.Name "hydra.paths.TypeAttributeLink")

-- | DSL constructor for hydra.paths.TypeGraph
typeGraph :: Typed.TypedTerm (M.Map Core.Name Paths.TypeNode) -> Typed.TypedTerm Paths.TypeGraph
typeGraph roots =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TypeGraph"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "roots"),
          Core.fieldTerm = (Typed.unTypedTerm roots)}]}))

-- | DSL accessor for the roots field of hydra.paths.TypeGraph
typeGraphRoots :: Typed.TypedTerm Paths.TypeGraph -> Typed.TypedTerm (M.Map Core.Name Paths.TypeNode)
typeGraphRoots x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.paths.TypeGraph"),
        Core.projectionFieldName = (Core.Name "roots")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.paths.TypeGraph
typeGraphTypeGraph :: Typed.TypedName Paths.TypeGraph
typeGraphTypeGraph = Typed.TypedName (Core.Name "hydra.paths.TypeGraph")

-- | DSL updater for the roots field of hydra.paths.TypeGraph
typeGraphWithRoots :: Typed.TypedTerm Paths.TypeGraph -> Typed.TypedTerm (M.Map Core.Name Paths.TypeNode) -> Typed.TypedTerm Paths.TypeGraph
typeGraphWithRoots original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TypeGraph"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "roots"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the attribute variant of hydra.paths.TypeLink
typeLinkAttribute :: Typed.TypedTerm Paths.TypeAttributeLink -> Typed.TypedTerm Paths.TypeLink
typeLinkAttribute x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.TypeLink"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "attribute"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the reference variant of hydra.paths.TypeLink
typeLinkReference :: Typed.TypedTerm Paths.TypeReferenceLink -> Typed.TypedTerm Paths.TypeLink
typeLinkReference x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.TypeLink"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "reference"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the subtype variant of hydra.paths.TypeLink
typeLinkSubtype :: Typed.TypedTerm Paths.SubtypeLink -> Typed.TypedTerm Paths.TypeLink
typeLinkSubtype x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.TypeLink"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "subtype"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.paths.TypeLink
typeLinkTypeLink :: Typed.TypedName Paths.TypeLink
typeLinkTypeLink = Typed.TypedName (Core.Name "hydra.paths.TypeLink")

-- | DSL constructor for hydra.paths.TypeNode
typeNode :: Typed.TypedTerm Core.Type -> Typed.TypedTerm [Paths.TypeLink] -> Typed.TypedTerm Paths.TypeNode
typeNode type_ links =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TypeNode"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Typed.unTypedTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "links"),
          Core.fieldTerm = (Typed.unTypedTerm links)}]}))

-- | DSL constructor for hydra.paths.TypeNodeId
typeNodeId :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtypePath -> Typed.TypedTerm Paths.TypeNodeId
typeNodeId root path =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TypeNodeId"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "root"),
          Core.fieldTerm = (Typed.unTypedTerm root)},
        Core.Field {
          Core.fieldName = (Core.Name "path"),
          Core.fieldTerm = (Typed.unTypedTerm path)}]}))

-- | DSL accessor for the path field of hydra.paths.TypeNodeId
typeNodeIdPath :: Typed.TypedTerm Paths.TypeNodeId -> Typed.TypedTerm Paths.SubtypePath
typeNodeIdPath x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.paths.TypeNodeId"),
        Core.projectionFieldName = (Core.Name "path")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the root field of hydra.paths.TypeNodeId
typeNodeIdRoot :: Typed.TypedTerm Paths.TypeNodeId -> Typed.TypedTerm Core.Name
typeNodeIdRoot x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.paths.TypeNodeId"),
        Core.projectionFieldName = (Core.Name "root")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.paths.TypeNodeId
typeNodeIdTypeNodeId :: Typed.TypedName Paths.TypeNodeId
typeNodeIdTypeNodeId = Typed.TypedName (Core.Name "hydra.paths.TypeNodeId")

-- | DSL updater for the path field of hydra.paths.TypeNodeId
typeNodeIdWithPath :: Typed.TypedTerm Paths.TypeNodeId -> Typed.TypedTerm Paths.SubtypePath -> Typed.TypedTerm Paths.TypeNodeId
typeNodeIdWithPath original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TypeNodeId"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "root"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.paths.TypeNodeId"),
              Core.projectionFieldName = (Core.Name "root")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "path"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the root field of hydra.paths.TypeNodeId
typeNodeIdWithRoot :: Typed.TypedTerm Paths.TypeNodeId -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TypeNodeId
typeNodeIdWithRoot original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TypeNodeId"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "root"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "path"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.paths.TypeNodeId"),
              Core.projectionFieldName = (Core.Name "path")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL accessor for the links field of hydra.paths.TypeNode
typeNodeLinks :: Typed.TypedTerm Paths.TypeNode -> Typed.TypedTerm [Paths.TypeLink]
typeNodeLinks x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.paths.TypeNode"),
        Core.projectionFieldName = (Core.Name "links")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.paths.TypeNode
typeNodeType :: Typed.TypedTerm Paths.TypeNode -> Typed.TypedTerm Core.Type
typeNodeType x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.paths.TypeNode"),
        Core.projectionFieldName = (Core.Name "type")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.paths.TypeNode
typeNodeTypeNode :: Typed.TypedName Paths.TypeNode
typeNodeTypeNode = Typed.TypedName (Core.Name "hydra.paths.TypeNode")

-- | DSL updater for the links field of hydra.paths.TypeNode
typeNodeWithLinks :: Typed.TypedTerm Paths.TypeNode -> Typed.TypedTerm [Paths.TypeLink] -> Typed.TypedTerm Paths.TypeNode
typeNodeWithLinks original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TypeNode"),
      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.paths.TypeNode"),
              Core.projectionFieldName = (Core.Name "type")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "links"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the type field of hydra.paths.TypeNode
typeNodeWithType :: Typed.TypedTerm Paths.TypeNode -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Paths.TypeNode
typeNodeWithType original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TypeNode"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "links"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.paths.TypeNode"),
              Core.projectionFieldName = (Core.Name "links")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.paths.TypeReferenceLink
typeReferenceLink :: Typed.TypedTerm Paths.SubtypeStep -> Typed.TypedTerm Paths.TypeReference -> Typed.TypedTerm Paths.TypeReferenceLink
typeReferenceLink step target =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TypeReferenceLink"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "step"),
          Core.fieldTerm = (Typed.unTypedTerm step)},
        Core.Field {
          Core.fieldName = (Core.Name "target"),
          Core.fieldTerm = (Typed.unTypedTerm target)}]}))

-- | DSL accessor for the step field of hydra.paths.TypeReferenceLink
typeReferenceLinkStep :: Typed.TypedTerm Paths.TypeReferenceLink -> Typed.TypedTerm Paths.SubtypeStep
typeReferenceLinkStep x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.paths.TypeReferenceLink"),
        Core.projectionFieldName = (Core.Name "step")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the target field of hydra.paths.TypeReferenceLink
typeReferenceLinkTarget :: Typed.TypedTerm Paths.TypeReferenceLink -> Typed.TypedTerm Paths.TypeReference
typeReferenceLinkTarget x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.paths.TypeReferenceLink"),
        Core.projectionFieldName = (Core.Name "target")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.paths.TypeReferenceLink
typeReferenceLinkTypeReferenceLink :: Typed.TypedName Paths.TypeReferenceLink
typeReferenceLinkTypeReferenceLink = Typed.TypedName (Core.Name "hydra.paths.TypeReferenceLink")

-- | DSL updater for the step field of hydra.paths.TypeReferenceLink
typeReferenceLinkWithStep :: Typed.TypedTerm Paths.TypeReferenceLink -> Typed.TypedTerm Paths.SubtypeStep -> Typed.TypedTerm Paths.TypeReferenceLink
typeReferenceLinkWithStep original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TypeReferenceLink"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "step"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "target"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.paths.TypeReferenceLink"),
              Core.projectionFieldName = (Core.Name "target")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the target field of hydra.paths.TypeReferenceLink
typeReferenceLinkWithTarget :: Typed.TypedTerm Paths.TypeReferenceLink -> Typed.TypedTerm Paths.TypeReference -> Typed.TypedTerm Paths.TypeReferenceLink
typeReferenceLinkWithTarget original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TypeReferenceLink"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "step"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.paths.TypeReferenceLink"),
              Core.projectionFieldName = (Core.Name "step")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "target"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the nominal variant of hydra.paths.TypeReference
typeReferenceNominal :: Typed.TypedTerm Paths.NominalTypeReference -> Typed.TypedTerm Paths.TypeReference
typeReferenceNominal x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.TypeReference"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "nominal"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.paths.TypeReference
typeReferenceTypeReference :: Typed.TypedName Paths.TypeReference
typeReferenceTypeReference = Typed.TypedName (Core.Name "hydra.paths.TypeReference")

-- | DSL injection for the variable variant of hydra.paths.TypeReference
typeReferenceVariable :: Typed.TypedTerm Paths.TypeVariableReference -> Typed.TypedTerm Paths.TypeReference
typeReferenceVariable x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.TypeReference"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "variable"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.paths.TypeVariableReference
typeVariableReference :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TypeNodeId -> Typed.TypedTerm Paths.TypeVariableReference
typeVariableReference variable boundByNode =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TypeVariableReference"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "variable"),
          Core.fieldTerm = (Typed.unTypedTerm variable)},
        Core.Field {
          Core.fieldName = (Core.Name "boundByNode"),
          Core.fieldTerm = (Typed.unTypedTerm boundByNode)}]}))

-- | DSL accessor for the boundByNode field of hydra.paths.TypeVariableReference
typeVariableReferenceBoundByNode :: Typed.TypedTerm Paths.TypeVariableReference -> Typed.TypedTerm Paths.TypeNodeId
typeVariableReferenceBoundByNode x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.paths.TypeVariableReference"),
        Core.projectionFieldName = (Core.Name "boundByNode")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.paths.TypeVariableReference
typeVariableReferenceTypeVariableReference :: Typed.TypedName Paths.TypeVariableReference
typeVariableReferenceTypeVariableReference = Typed.TypedName (Core.Name "hydra.paths.TypeVariableReference")

-- | DSL accessor for the variable field of hydra.paths.TypeVariableReference
typeVariableReferenceVariable :: Typed.TypedTerm Paths.TypeVariableReference -> Typed.TypedTerm Core.Name
typeVariableReferenceVariable x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.paths.TypeVariableReference"),
        Core.projectionFieldName = (Core.Name "variable")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the boundByNode field of hydra.paths.TypeVariableReference
typeVariableReferenceWithBoundByNode :: Typed.TypedTerm Paths.TypeVariableReference -> Typed.TypedTerm Paths.TypeNodeId -> Typed.TypedTerm Paths.TypeVariableReference
typeVariableReferenceWithBoundByNode original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TypeVariableReference"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "variable"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.paths.TypeVariableReference"),
              Core.projectionFieldName = (Core.Name "variable")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "boundByNode"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the variable field of hydra.paths.TypeVariableReference
typeVariableReferenceWithVariable :: Typed.TypedTerm Paths.TypeVariableReference -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TypeVariableReference
typeVariableReferenceWithVariable original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.TypeVariableReference"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "variable"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "boundByNode"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.paths.TypeVariableReference"),
              Core.projectionFieldName = (Core.Name "boundByNode")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL accessor for the body of hydra.paths.SubtermPath
unSubtermPath :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm [Paths.SubtermStep]
unSubtermPath x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.paths.SubtermPath")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.paths.SubtypePath
unSubtypePath :: Typed.TypedTerm Paths.SubtypePath -> Typed.TypedTerm [Paths.SubtypeStep]
unSubtypePath x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.paths.SubtypePath")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))