hydra-kernel-0.17.6: 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | DSL constructor for hydra.paths.SubtermNode
subtermNode :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.TypeScheme -> Typed.TypedTerm [Paths.SubtermLink] -> Typed.TypedTerm Paths.SubtermNode
subtermNode name type_ links =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.SubtermNode"),
      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_)},
        Core.Field {
          Core.fieldName = (Core.Name "links"),
          Core.fieldTerm = (Typed.unTypedTerm links)}]}))

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

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

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

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

-- | DSL updater for the links field of hydra.paths.SubtermNode
subtermNodeWithLinks :: Typed.TypedTerm Paths.SubtermNode -> Typed.TypedTerm [Paths.SubtermLink] -> Typed.TypedTerm Paths.SubtermNode
subtermNodeWithLinks original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.SubtermNode"),
      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.SubtermNode"),
              Core.projectionFieldName = (Core.Name "name")})),
            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.SubtermNode"),
              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 name field of hydra.paths.SubtermNode
subtermNodeWithName :: Typed.TypedTerm Paths.SubtermNode -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtermNode
subtermNodeWithName original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.SubtermNode"),
      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.SubtermNode"),
              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.SubtermNode"),
              Core.projectionFieldName = (Core.Name "links")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.paths.SubtermNode
subtermNodeWithType :: Typed.TypedTerm Paths.SubtermNode -> Typed.TypedTerm Core.TypeScheme -> Typed.TypedTerm Paths.SubtermNode
subtermNodeWithType original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.SubtermNode"),
      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.SubtermNode"),
              Core.projectionFieldName = (Core.Name "name")})),
            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.SubtermNode"),
              Core.projectionFieldName = (Core.Name "links")})),
            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 constructor for hydra.paths.SubtermProperty
subtermProperty :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Paths.SubtermProperty
subtermProperty path target =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.SubtermProperty"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "path"),
          Core.fieldTerm = (Typed.unTypedTerm path)},
        Core.Field {
          Core.fieldName = (Core.Name "target"),
          Core.fieldTerm = (Typed.unTypedTerm target)}]}))

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

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

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

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

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

-- | 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 mapKey variant of hydra.paths.SubtermStep
subtermStepMapKey :: Typed.TypedTerm Int -> Typed.TypedTerm Paths.SubtermStep
subtermStepMapKey x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "mapKey"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the mapValue variant of hydra.paths.SubtermStep
subtermStepMapValue :: Typed.TypedTerm Int -> Typed.TypedTerm Paths.SubtermStep
subtermStepMapValue x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "mapValue"),
        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.SubtypeAttribute
subtypeAttribute :: Typed.TypedTerm Paths.SubtypePath -> Typed.TypedTerm Paths.TypeAttribute -> Typed.TypedTerm Paths.SubtypeAttribute
subtypeAttribute path target =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeAttribute"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "path"),
          Core.fieldTerm = (Typed.unTypedTerm path)},
        Core.Field {
          Core.fieldName = (Core.Name "target"),
          Core.fieldTerm = (Typed.unTypedTerm target)}]}))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | DSL updater for the name field of hydra.paths.SubtypeNode
subtypeNodeWithName :: Typed.TypedTerm Paths.SubtypeNode -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtypeNode
subtypeNodeWithName original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeNode"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          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.SubtypeNode"),
              Core.projectionFieldName = (Core.Name "links")})),
            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 constructor for hydra.paths.SubtypeProperty
subtypeProperty :: Typed.TypedTerm Paths.SubtypePath -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Paths.SubtypeProperty
subtypeProperty path target =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeProperty"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "path"),
          Core.fieldTerm = (Typed.unTypedTerm path)},
        Core.Field {
          Core.fieldName = (Core.Name "target"),
          Core.fieldTerm = (Typed.unTypedTerm target)}]}))

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

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

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

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

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

-- | 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.TermAttribute
termAttributeCasesTypeName :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.TermAttribute
termAttributeCasesTypeName x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.paths.TermAttribute"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "casesTypeName"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | 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)}))