hydra-build-0.17.3: src/main/haskell/Hydra/Dsl/Build/Format.hs

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

-- | DSL functions for hydra.build.format

module Hydra.Dsl.Build.Format where

import qualified Hydra.Build.Format as Format
import qualified Hydra.Core as Core
import qualified Hydra.Decode.Build.Format as DecodeBuildFormat
import qualified Hydra.Dsl.Packaging as DslPackaging
import qualified Hydra.Encode.Build.Format as EncodeBuildFormat
import qualified Hydra.Packaging as Packaging
import qualified Hydra.Typed as Typed
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
import qualified Data.Scientific as Sci
import qualified Data.Map as M

-- | DSL constructor for hydra.build.format.DefinitionNameConventionProfile
definitionNameConventionProfile :: Typed.TypedTerm Format.Severity -> Typed.TypedTerm Bool -> Typed.TypedTerm Format.DefinitionNameConventionProfile
definitionNameConventionProfile severity allowUnderscores =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionNameConventionProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "severity"),
          Core.fieldTerm = (Typed.unTypedTerm severity)},
        Core.Field {
          Core.fieldName = (Core.Name "allowUnderscores"),
          Core.fieldTerm = (Typed.unTypedTerm allowUnderscores)}]}))

-- | DSL accessor for the allowUnderscores field of hydra.build.format.DefinitionNameConventionProfile
definitionNameConventionProfileAllowUnderscores :: Typed.TypedTerm Format.DefinitionNameConventionProfile -> Typed.TypedTerm Bool
definitionNameConventionProfileAllowUnderscores x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionNameConventionProfile"),
        Core.projectionFieldName = (Core.Name "allowUnderscores")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.build.format.DefinitionNameConventionProfile
definitionNameConventionProfileDefinitionNameConventionProfile :: Typed.TypedName Format.DefinitionNameConventionProfile
definitionNameConventionProfileDefinitionNameConventionProfile =
    Typed.TypedName (Core.Name "hydra.build.format.DefinitionNameConventionProfile")

-- | DSL accessor for the severity field of hydra.build.format.DefinitionNameConventionProfile
definitionNameConventionProfileSeverity :: Typed.TypedTerm Format.DefinitionNameConventionProfile -> Typed.TypedTerm Format.Severity
definitionNameConventionProfileSeverity x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionNameConventionProfile"),
        Core.projectionFieldName = (Core.Name "severity")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the allowUnderscores field of hydra.build.format.DefinitionNameConventionProfile
definitionNameConventionProfileWithAllowUnderscores :: Typed.TypedTerm Format.DefinitionNameConventionProfile -> Typed.TypedTerm Bool -> Typed.TypedTerm Format.DefinitionNameConventionProfile
definitionNameConventionProfileWithAllowUnderscores original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionNameConventionProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "severity"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionNameConventionProfile"),
              Core.projectionFieldName = (Core.Name "severity")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "allowUnderscores"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the severity field of hydra.build.format.DefinitionNameConventionProfile
definitionNameConventionProfileWithSeverity :: Typed.TypedTerm Format.DefinitionNameConventionProfile -> Typed.TypedTerm Format.Severity -> Typed.TypedTerm Format.DefinitionNameConventionProfile
definitionNameConventionProfileWithSeverity original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionNameConventionProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "severity"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "allowUnderscores"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionNameConventionProfile"),
              Core.projectionFieldName = (Core.Name "allowUnderscores")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.build.format.DefinitionValidationProfile
definitionValidationProfile :: Typed.TypedTerm (Maybe Format.DocumentationProfile) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.DefinitionNameConventionProfile) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.DefinitionValidationProfile
definitionValidationProfile hasDescription ordering nameConvention notInModuleName duplicateName =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "hasDescription"),
          Core.fieldTerm = (Typed.unTypedTerm hasDescription)},
        Core.Field {
          Core.fieldName = (Core.Name "ordering"),
          Core.fieldTerm = (Typed.unTypedTerm ordering)},
        Core.Field {
          Core.fieldName = (Core.Name "nameConvention"),
          Core.fieldTerm = (Typed.unTypedTerm nameConvention)},
        Core.Field {
          Core.fieldName = (Core.Name "notInModuleName"),
          Core.fieldTerm = (Typed.unTypedTerm notInModuleName)},
        Core.Field {
          Core.fieldName = (Core.Name "duplicateName"),
          Core.fieldTerm = (Typed.unTypedTerm duplicateName)}]}))

-- | DSL name token for hydra.build.format.DefinitionValidationProfile
definitionValidationProfileDefinitionValidationProfile :: Typed.TypedName Format.DefinitionValidationProfile
definitionValidationProfileDefinitionValidationProfile =
    Typed.TypedName (Core.Name "hydra.build.format.DefinitionValidationProfile")

-- | DSL accessor for the duplicateName field of hydra.build.format.DefinitionValidationProfile
definitionValidationProfileDuplicateName :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.Severity)
definitionValidationProfileDuplicateName x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
        Core.projectionFieldName = (Core.Name "duplicateName")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the hasDescription field of hydra.build.format.DefinitionValidationProfile
definitionValidationProfileHasDescription :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.DocumentationProfile)
definitionValidationProfileHasDescription x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
        Core.projectionFieldName = (Core.Name "hasDescription")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the nameConvention field of hydra.build.format.DefinitionValidationProfile
definitionValidationProfileNameConvention :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.DefinitionNameConventionProfile)
definitionValidationProfileNameConvention x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
        Core.projectionFieldName = (Core.Name "nameConvention")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the notInModuleName field of hydra.build.format.DefinitionValidationProfile
definitionValidationProfileNotInModuleName :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.Severity)
definitionValidationProfileNotInModuleName x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
        Core.projectionFieldName = (Core.Name "notInModuleName")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the ordering field of hydra.build.format.DefinitionValidationProfile
definitionValidationProfileOrdering :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.Severity)
definitionValidationProfileOrdering x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
        Core.projectionFieldName = (Core.Name "ordering")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the duplicateName field of hydra.build.format.DefinitionValidationProfile
definitionValidationProfileWithDuplicateName :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.DefinitionValidationProfile
definitionValidationProfileWithDuplicateName original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "hasDescription"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
              Core.projectionFieldName = (Core.Name "hasDescription")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "ordering"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
              Core.projectionFieldName = (Core.Name "ordering")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "nameConvention"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
              Core.projectionFieldName = (Core.Name "nameConvention")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "notInModuleName"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
              Core.projectionFieldName = (Core.Name "notInModuleName")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "duplicateName"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the hasDescription field of hydra.build.format.DefinitionValidationProfile
definitionValidationProfileWithHasDescription :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.DocumentationProfile) -> Typed.TypedTerm Format.DefinitionValidationProfile
definitionValidationProfileWithHasDescription original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "hasDescription"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "ordering"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
              Core.projectionFieldName = (Core.Name "ordering")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "nameConvention"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
              Core.projectionFieldName = (Core.Name "nameConvention")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "notInModuleName"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
              Core.projectionFieldName = (Core.Name "notInModuleName")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "duplicateName"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
              Core.projectionFieldName = (Core.Name "duplicateName")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the nameConvention field of hydra.build.format.DefinitionValidationProfile
definitionValidationProfileWithNameConvention :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.DefinitionNameConventionProfile) -> Typed.TypedTerm Format.DefinitionValidationProfile
definitionValidationProfileWithNameConvention original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "hasDescription"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
              Core.projectionFieldName = (Core.Name "hasDescription")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "ordering"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
              Core.projectionFieldName = (Core.Name "ordering")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "nameConvention"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "notInModuleName"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
              Core.projectionFieldName = (Core.Name "notInModuleName")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "duplicateName"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
              Core.projectionFieldName = (Core.Name "duplicateName")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the notInModuleName field of hydra.build.format.DefinitionValidationProfile
definitionValidationProfileWithNotInModuleName :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.DefinitionValidationProfile
definitionValidationProfileWithNotInModuleName original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "hasDescription"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
              Core.projectionFieldName = (Core.Name "hasDescription")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "ordering"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
              Core.projectionFieldName = (Core.Name "ordering")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "nameConvention"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
              Core.projectionFieldName = (Core.Name "nameConvention")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "notInModuleName"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "duplicateName"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
              Core.projectionFieldName = (Core.Name "duplicateName")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the ordering field of hydra.build.format.DefinitionValidationProfile
definitionValidationProfileWithOrdering :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.DefinitionValidationProfile
definitionValidationProfileWithOrdering original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "hasDescription"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
              Core.projectionFieldName = (Core.Name "hasDescription")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "ordering"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "nameConvention"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
              Core.projectionFieldName = (Core.Name "nameConvention")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "notInModuleName"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
              Core.projectionFieldName = (Core.Name "notInModuleName")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "duplicateName"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
              Core.projectionFieldName = (Core.Name "duplicateName")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.build.format.DigestEntry
digestEntry :: Typed.TypedTerm Format.DigestKind -> Typed.TypedTerm Format.Sha256Hash -> Typed.TypedTerm Format.DigestEntry
digestEntry kind hash =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.DigestEntry"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "kind"),
          Core.fieldTerm = (Typed.unTypedTerm kind)},
        Core.Field {
          Core.fieldName = (Core.Name "hash"),
          Core.fieldTerm = (Typed.unTypedTerm hash)}]}))

-- | DSL name token for hydra.build.format.DigestEntry
digestEntryDigestEntry :: Typed.TypedName Format.DigestEntry
digestEntryDigestEntry = Typed.TypedName (Core.Name "hydra.build.format.DigestEntry")

-- | DSL accessor for the hash field of hydra.build.format.DigestEntry
digestEntryHash :: Typed.TypedTerm Format.DigestEntry -> Typed.TypedTerm Format.Sha256Hash
digestEntryHash x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.DigestEntry"),
        Core.projectionFieldName = (Core.Name "hash")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the kind field of hydra.build.format.DigestEntry
digestEntryKind :: Typed.TypedTerm Format.DigestEntry -> Typed.TypedTerm Format.DigestKind
digestEntryKind x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.DigestEntry"),
        Core.projectionFieldName = (Core.Name "kind")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the hash field of hydra.build.format.DigestEntry
digestEntryWithHash :: Typed.TypedTerm Format.DigestEntry -> Typed.TypedTerm Format.Sha256Hash -> Typed.TypedTerm Format.DigestEntry
digestEntryWithHash original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.DigestEntry"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "kind"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.DigestEntry"),
              Core.projectionFieldName = (Core.Name "kind")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "hash"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the kind field of hydra.build.format.DigestEntry
digestEntryWithKind :: Typed.TypedTerm Format.DigestEntry -> Typed.TypedTerm Format.DigestKind -> Typed.TypedTerm Format.DigestEntry
digestEntryWithKind original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.DigestEntry"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "kind"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "hash"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.DigestEntry"),
              Core.projectionFieldName = (Core.Name "hash")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL name token for hydra.build.format.DigestKind
digestKindDigestKind :: Typed.TypedName Format.DigestKind
digestKindDigestKind = Typed.TypedName (Core.Name "hydra.build.format.DigestKind")

-- | DSL injection for the dslSource variant of hydra.build.format.DigestKind
digestKindDslSource :: Typed.TypedTerm Format.DigestKind
digestKindDslSource =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.build.format.DigestKind"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "dslSource"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the jsonFile variant of hydra.build.format.DigestKind
digestKindJsonFile :: Typed.TypedTerm Format.DigestKind
digestKindJsonFile =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.build.format.DigestKind"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "jsonFile"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the other variant of hydra.build.format.DigestKind
digestKindOther :: Typed.TypedTerm Format.DigestKind
digestKindOther =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.build.format.DigestKind"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "other"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the runtimeFile variant of hydra.build.format.DigestKind
digestKindRuntimeFile :: Typed.TypedTerm Format.DigestKind
digestKindRuntimeFile =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.build.format.DigestKind"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "runtimeFile"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the targetFile variant of hydra.build.format.DigestKind
digestKindTargetFile :: Typed.TypedTerm Format.DigestKind
digestKindTargetFile =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.build.format.DigestKind"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "targetFile"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL constructor for hydra.build.format.DocumentationProfile
documentationProfile :: Typed.TypedTerm Format.Severity -> Typed.TypedTerm Bool -> Typed.TypedTerm Format.DocumentationProfile
documentationProfile severity exemptDeprecated =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.DocumentationProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "severity"),
          Core.fieldTerm = (Typed.unTypedTerm severity)},
        Core.Field {
          Core.fieldName = (Core.Name "exemptDeprecated"),
          Core.fieldTerm = (Typed.unTypedTerm exemptDeprecated)}]}))

-- | DSL name token for hydra.build.format.DocumentationProfile
documentationProfileDocumentationProfile :: Typed.TypedName Format.DocumentationProfile
documentationProfileDocumentationProfile = Typed.TypedName (Core.Name "hydra.build.format.DocumentationProfile")

-- | DSL accessor for the exemptDeprecated field of hydra.build.format.DocumentationProfile
documentationProfileExemptDeprecated :: Typed.TypedTerm Format.DocumentationProfile -> Typed.TypedTerm Bool
documentationProfileExemptDeprecated x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.DocumentationProfile"),
        Core.projectionFieldName = (Core.Name "exemptDeprecated")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the severity field of hydra.build.format.DocumentationProfile
documentationProfileSeverity :: Typed.TypedTerm Format.DocumentationProfile -> Typed.TypedTerm Format.Severity
documentationProfileSeverity x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.DocumentationProfile"),
        Core.projectionFieldName = (Core.Name "severity")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the exemptDeprecated field of hydra.build.format.DocumentationProfile
documentationProfileWithExemptDeprecated :: Typed.TypedTerm Format.DocumentationProfile -> Typed.TypedTerm Bool -> Typed.TypedTerm Format.DocumentationProfile
documentationProfileWithExemptDeprecated original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.DocumentationProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "severity"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.DocumentationProfile"),
              Core.projectionFieldName = (Core.Name "severity")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "exemptDeprecated"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the severity field of hydra.build.format.DocumentationProfile
documentationProfileWithSeverity :: Typed.TypedTerm Format.DocumentationProfile -> Typed.TypedTerm Format.Severity -> Typed.TypedTerm Format.DocumentationProfile
documentationProfileWithSeverity original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.DocumentationProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "severity"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "exemptDeprecated"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.DocumentationProfile"),
              Core.projectionFieldName = (Core.Name "exemptDeprecated")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.build.format.Generation
generation :: Typed.TypedTerm String -> Typed.TypedTerm Format.GenerationMode -> Typed.TypedTerm Format.LanguageName -> Typed.TypedTerm (Maybe Packaging.Version) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Format.Generation
generation generatorId mode host hydraVersion revision timestamp =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.Generation"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "generatorId"),
          Core.fieldTerm = (Typed.unTypedTerm generatorId)},
        Core.Field {
          Core.fieldName = (Core.Name "mode"),
          Core.fieldTerm = (Typed.unTypedTerm mode)},
        Core.Field {
          Core.fieldName = (Core.Name "host"),
          Core.fieldTerm = (Typed.unTypedTerm host)},
        Core.Field {
          Core.fieldName = (Core.Name "hydraVersion"),
          Core.fieldTerm = (Typed.unTypedTerm hydraVersion)},
        Core.Field {
          Core.fieldName = (Core.Name "revision"),
          Core.fieldTerm = (Typed.unTypedTerm revision)},
        Core.Field {
          Core.fieldName = (Core.Name "timestamp"),
          Core.fieldTerm = (Typed.unTypedTerm timestamp)}]}))

-- | DSL name token for hydra.build.format.Generation
generationGeneration :: Typed.TypedName Format.Generation
generationGeneration = Typed.TypedName (Core.Name "hydra.build.format.Generation")

-- | DSL accessor for the generatorId field of hydra.build.format.Generation
generationGeneratorId :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm String
generationGeneratorId x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
        Core.projectionFieldName = (Core.Name "generatorId")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the host field of hydra.build.format.Generation
generationHost :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm Format.LanguageName
generationHost x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
        Core.projectionFieldName = (Core.Name "host")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the hydraVersion field of hydra.build.format.Generation
generationHydraVersion :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm (Maybe Packaging.Version)
generationHydraVersion x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
        Core.projectionFieldName = (Core.Name "hydraVersion")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the mode field of hydra.build.format.Generation
generationMode :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm Format.GenerationMode
generationMode x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
        Core.projectionFieldName = (Core.Name "mode")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.build.format.GenerationMode
generationModeGenerationMode :: Typed.TypedName Format.GenerationMode
generationModeGenerationMode = Typed.TypedName (Core.Name "hydra.build.format.GenerationMode")

-- | DSL injection for the published variant of hydra.build.format.GenerationMode
generationModePublished :: Typed.TypedTerm Format.GenerationMode
generationModePublished =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.build.format.GenerationMode"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "published"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the shim variant of hydra.build.format.GenerationMode
generationModeShim :: Typed.TypedTerm Format.GenerationMode
generationModeShim =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.build.format.GenerationMode"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "shim"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL accessor for the revision field of hydra.build.format.Generation
generationRevision :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm (Maybe String)
generationRevision x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
        Core.projectionFieldName = (Core.Name "revision")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the timestamp field of hydra.build.format.Generation
generationTimestamp :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm (Maybe String)
generationTimestamp x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
        Core.projectionFieldName = (Core.Name "timestamp")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the generatorId field of hydra.build.format.Generation
generationWithGeneratorId :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm String -> Typed.TypedTerm Format.Generation
generationWithGeneratorId original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.Generation"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "generatorId"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "mode"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
              Core.projectionFieldName = (Core.Name "mode")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "host"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
              Core.projectionFieldName = (Core.Name "host")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "hydraVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
              Core.projectionFieldName = (Core.Name "hydraVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "revision"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
              Core.projectionFieldName = (Core.Name "revision")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "timestamp"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
              Core.projectionFieldName = (Core.Name "timestamp")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the host field of hydra.build.format.Generation
generationWithHost :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm Format.LanguageName -> Typed.TypedTerm Format.Generation
generationWithHost original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.Generation"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "generatorId"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
              Core.projectionFieldName = (Core.Name "generatorId")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "mode"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
              Core.projectionFieldName = (Core.Name "mode")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "host"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "hydraVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
              Core.projectionFieldName = (Core.Name "hydraVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "revision"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
              Core.projectionFieldName = (Core.Name "revision")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "timestamp"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
              Core.projectionFieldName = (Core.Name "timestamp")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the hydraVersion field of hydra.build.format.Generation
generationWithHydraVersion :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm (Maybe Packaging.Version) -> Typed.TypedTerm Format.Generation
generationWithHydraVersion original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.Generation"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "generatorId"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
              Core.projectionFieldName = (Core.Name "generatorId")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "mode"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
              Core.projectionFieldName = (Core.Name "mode")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "host"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
              Core.projectionFieldName = (Core.Name "host")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "hydraVersion"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "revision"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
              Core.projectionFieldName = (Core.Name "revision")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "timestamp"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
              Core.projectionFieldName = (Core.Name "timestamp")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the mode field of hydra.build.format.Generation
generationWithMode :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm Format.GenerationMode -> Typed.TypedTerm Format.Generation
generationWithMode original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.Generation"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "generatorId"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
              Core.projectionFieldName = (Core.Name "generatorId")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "mode"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "host"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
              Core.projectionFieldName = (Core.Name "host")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "hydraVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
              Core.projectionFieldName = (Core.Name "hydraVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "revision"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
              Core.projectionFieldName = (Core.Name "revision")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "timestamp"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
              Core.projectionFieldName = (Core.Name "timestamp")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the revision field of hydra.build.format.Generation
generationWithRevision :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Format.Generation
generationWithRevision original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.Generation"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "generatorId"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
              Core.projectionFieldName = (Core.Name "generatorId")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "mode"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
              Core.projectionFieldName = (Core.Name "mode")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "host"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
              Core.projectionFieldName = (Core.Name "host")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "hydraVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
              Core.projectionFieldName = (Core.Name "hydraVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "revision"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "timestamp"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
              Core.projectionFieldName = (Core.Name "timestamp")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the timestamp field of hydra.build.format.Generation
generationWithTimestamp :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Format.Generation
generationWithTimestamp original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.Generation"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "generatorId"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
              Core.projectionFieldName = (Core.Name "generatorId")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "mode"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
              Core.projectionFieldName = (Core.Name "mode")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "host"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
              Core.projectionFieldName = (Core.Name "host")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "hydraVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
              Core.projectionFieldName = (Core.Name "hydraVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "revision"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),
              Core.projectionFieldName = (Core.Name "revision")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "timestamp"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL name token for hydra.build.format.HostOverride
hostOverrideHostOverride :: Typed.TypedName Format.HostOverride
hostOverrideHostOverride = Typed.TypedName (Core.Name "hydra.build.format.HostOverride")

-- | DSL injection for the local variant of hydra.build.format.HostOverride
hostOverrideLocal :: Typed.TypedTerm Format.HostOverride
hostOverrideLocal =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.build.format.HostOverride"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "local"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL injection for the version variant of hydra.build.format.HostOverride
hostOverrideVersion :: Typed.TypedTerm Packaging.Version -> Typed.TypedTerm Format.HostOverride
hostOverrideVersion x =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.build.format.HostOverride"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "version"),
        Core.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.build.format.InputDigest
inputDigest :: Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm (Maybe Format.Sha256Hash) -> Typed.TypedTerm (M.Map Packaging.PackageName Format.Sha256Hash) -> Typed.TypedTerm (M.Map Packaging.ModuleName Format.Sha256Hash) -> Typed.TypedTerm Format.InputDigest
inputDigest digestFormatVersion moduleFormatVersion selfHash dependencyHashes moduleHashes =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.InputDigest"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "digestFormatVersion"),
          Core.fieldTerm = (Typed.unTypedTerm digestFormatVersion)},
        Core.Field {
          Core.fieldName = (Core.Name "moduleFormatVersion"),
          Core.fieldTerm = (Typed.unTypedTerm moduleFormatVersion)},
        Core.Field {
          Core.fieldName = (Core.Name "selfHash"),
          Core.fieldTerm = (Typed.unTypedTerm selfHash)},
        Core.Field {
          Core.fieldName = (Core.Name "dependencyHashes"),
          Core.fieldTerm = (Typed.unTypedTerm dependencyHashes)},
        Core.Field {
          Core.fieldName = (Core.Name "moduleHashes"),
          Core.fieldTerm = (Typed.unTypedTerm moduleHashes)}]}))

-- | DSL accessor for the dependencyHashes field of hydra.build.format.InputDigest
inputDigestDependencyHashes :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm (M.Map Packaging.PackageName Format.Sha256Hash)
inputDigestDependencyHashes x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),
        Core.projectionFieldName = (Core.Name "dependencyHashes")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the digestFormatVersion field of hydra.build.format.InputDigest
inputDigestDigestFormatVersion :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm Int
inputDigestDigestFormatVersion x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),
        Core.projectionFieldName = (Core.Name "digestFormatVersion")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.build.format.InputDigest
inputDigestInputDigest :: Typed.TypedName Format.InputDigest
inputDigestInputDigest = Typed.TypedName (Core.Name "hydra.build.format.InputDigest")

-- | DSL accessor for the moduleFormatVersion field of hydra.build.format.InputDigest
inputDigestModuleFormatVersion :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm Int
inputDigestModuleFormatVersion x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),
        Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the moduleHashes field of hydra.build.format.InputDigest
inputDigestModuleHashes :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm (M.Map Packaging.ModuleName Format.Sha256Hash)
inputDigestModuleHashes x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),
        Core.projectionFieldName = (Core.Name "moduleHashes")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the selfHash field of hydra.build.format.InputDigest
inputDigestSelfHash :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm (Maybe Format.Sha256Hash)
inputDigestSelfHash x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),
        Core.projectionFieldName = (Core.Name "selfHash")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the dependencyHashes field of hydra.build.format.InputDigest
inputDigestWithDependencyHashes :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm (M.Map Packaging.PackageName Format.Sha256Hash) -> Typed.TypedTerm Format.InputDigest
inputDigestWithDependencyHashes original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.InputDigest"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "digestFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),
              Core.projectionFieldName = (Core.Name "digestFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "moduleFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),
              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "selfHash"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),
              Core.projectionFieldName = (Core.Name "selfHash")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "dependencyHashes"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "moduleHashes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),
              Core.projectionFieldName = (Core.Name "moduleHashes")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the digestFormatVersion field of hydra.build.format.InputDigest
inputDigestWithDigestFormatVersion :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm Int -> Typed.TypedTerm Format.InputDigest
inputDigestWithDigestFormatVersion original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.InputDigest"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "digestFormatVersion"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "moduleFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),
              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "selfHash"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),
              Core.projectionFieldName = (Core.Name "selfHash")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "dependencyHashes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),
              Core.projectionFieldName = (Core.Name "dependencyHashes")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "moduleHashes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),
              Core.projectionFieldName = (Core.Name "moduleHashes")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the moduleFormatVersion field of hydra.build.format.InputDigest
inputDigestWithModuleFormatVersion :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm Int -> Typed.TypedTerm Format.InputDigest
inputDigestWithModuleFormatVersion original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.InputDigest"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "digestFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),
              Core.projectionFieldName = (Core.Name "digestFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "moduleFormatVersion"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "selfHash"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),
              Core.projectionFieldName = (Core.Name "selfHash")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "dependencyHashes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),
              Core.projectionFieldName = (Core.Name "dependencyHashes")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "moduleHashes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),
              Core.projectionFieldName = (Core.Name "moduleHashes")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the moduleHashes field of hydra.build.format.InputDigest
inputDigestWithModuleHashes :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm (M.Map Packaging.ModuleName Format.Sha256Hash) -> Typed.TypedTerm Format.InputDigest
inputDigestWithModuleHashes original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.InputDigest"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "digestFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),
              Core.projectionFieldName = (Core.Name "digestFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "moduleFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),
              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "selfHash"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),
              Core.projectionFieldName = (Core.Name "selfHash")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "dependencyHashes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),
              Core.projectionFieldName = (Core.Name "dependencyHashes")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "moduleHashes"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the selfHash field of hydra.build.format.InputDigest
inputDigestWithSelfHash :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm (Maybe Format.Sha256Hash) -> Typed.TypedTerm Format.InputDigest
inputDigestWithSelfHash original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.InputDigest"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "digestFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),
              Core.projectionFieldName = (Core.Name "digestFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "moduleFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),
              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "selfHash"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "dependencyHashes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),
              Core.projectionFieldName = (Core.Name "dependencyHashes")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "moduleHashes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),
              Core.projectionFieldName = (Core.Name "moduleHashes")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for the hydra.build.format.LanguageName wrapper
languageName :: Typed.TypedTerm String -> Typed.TypedTerm Format.LanguageName
languageName x =
    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.build.format.LanguageName"),
      Core.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.build.format.LanguageName
languageNameLanguageName :: Typed.TypedName Format.LanguageName
languageNameLanguageName = Typed.TypedName (Core.Name "hydra.build.format.LanguageName")

-- | DSL constructor for hydra.build.format.ModuleValidationProfile
moduleValidationProfile :: Typed.TypedTerm (Maybe Format.DefinitionValidationProfile) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.ModuleValidationProfile
moduleValidationProfile definitions nameConvention conflictingVariantName =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "definitions"),
          Core.fieldTerm = (Typed.unTypedTerm definitions)},
        Core.Field {
          Core.fieldName = (Core.Name "nameConvention"),
          Core.fieldTerm = (Typed.unTypedTerm nameConvention)},
        Core.Field {
          Core.fieldName = (Core.Name "conflictingVariantName"),
          Core.fieldTerm = (Typed.unTypedTerm conflictingVariantName)}]}))

-- | DSL accessor for the conflictingVariantName field of hydra.build.format.ModuleValidationProfile
moduleValidationProfileConflictingVariantName :: Typed.TypedTerm Format.ModuleValidationProfile -> Typed.TypedTerm (Maybe Format.Severity)
moduleValidationProfileConflictingVariantName x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"),
        Core.projectionFieldName = (Core.Name "conflictingVariantName")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the definitions field of hydra.build.format.ModuleValidationProfile
moduleValidationProfileDefinitions :: Typed.TypedTerm Format.ModuleValidationProfile -> Typed.TypedTerm (Maybe Format.DefinitionValidationProfile)
moduleValidationProfileDefinitions x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"),
        Core.projectionFieldName = (Core.Name "definitions")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.build.format.ModuleValidationProfile
moduleValidationProfileModuleValidationProfile :: Typed.TypedName Format.ModuleValidationProfile
moduleValidationProfileModuleValidationProfile = Typed.TypedName (Core.Name "hydra.build.format.ModuleValidationProfile")

-- | DSL accessor for the nameConvention field of hydra.build.format.ModuleValidationProfile
moduleValidationProfileNameConvention :: Typed.TypedTerm Format.ModuleValidationProfile -> Typed.TypedTerm (Maybe Format.Severity)
moduleValidationProfileNameConvention x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"),
        Core.projectionFieldName = (Core.Name "nameConvention")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the conflictingVariantName field of hydra.build.format.ModuleValidationProfile
moduleValidationProfileWithConflictingVariantName :: Typed.TypedTerm Format.ModuleValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.ModuleValidationProfile
moduleValidationProfileWithConflictingVariantName original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "definitions"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"),
              Core.projectionFieldName = (Core.Name "definitions")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "nameConvention"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"),
              Core.projectionFieldName = (Core.Name "nameConvention")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "conflictingVariantName"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the definitions field of hydra.build.format.ModuleValidationProfile
moduleValidationProfileWithDefinitions :: Typed.TypedTerm Format.ModuleValidationProfile -> Typed.TypedTerm (Maybe Format.DefinitionValidationProfile) -> Typed.TypedTerm Format.ModuleValidationProfile
moduleValidationProfileWithDefinitions original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "definitions"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "nameConvention"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"),
              Core.projectionFieldName = (Core.Name "nameConvention")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "conflictingVariantName"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"),
              Core.projectionFieldName = (Core.Name "conflictingVariantName")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the nameConvention field of hydra.build.format.ModuleValidationProfile
moduleValidationProfileWithNameConvention :: Typed.TypedTerm Format.ModuleValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.ModuleValidationProfile
moduleValidationProfileWithNameConvention original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "definitions"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"),
              Core.projectionFieldName = (Core.Name "definitions")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "nameConvention"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "conflictingVariantName"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"),
              Core.projectionFieldName = (Core.Name "conflictingVariantName")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.build.format.OutputDigest
outputDigest :: Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm String -> Typed.TypedTerm Format.Generation -> Typed.TypedTerm (Maybe Format.Sha256Hash) -> Typed.TypedTerm (M.Map Packaging.PackageName Format.Sha256Hash) -> Typed.TypedTerm (M.Map String Format.DigestEntry) -> Typed.TypedTerm (M.Map String Format.DigestEntry) -> Typed.TypedTerm Format.OutputDigest
outputDigest digestFormatVersion moduleFormatVersion generator generation selfHash dependencyHashes inputs outputs =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.OutputDigest"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "digestFormatVersion"),
          Core.fieldTerm = (Typed.unTypedTerm digestFormatVersion)},
        Core.Field {
          Core.fieldName = (Core.Name "moduleFormatVersion"),
          Core.fieldTerm = (Typed.unTypedTerm moduleFormatVersion)},
        Core.Field {
          Core.fieldName = (Core.Name "generator"),
          Core.fieldTerm = (Typed.unTypedTerm generator)},
        Core.Field {
          Core.fieldName = (Core.Name "generation"),
          Core.fieldTerm = (Typed.unTypedTerm generation)},
        Core.Field {
          Core.fieldName = (Core.Name "selfHash"),
          Core.fieldTerm = (Typed.unTypedTerm selfHash)},
        Core.Field {
          Core.fieldName = (Core.Name "dependencyHashes"),
          Core.fieldTerm = (Typed.unTypedTerm dependencyHashes)},
        Core.Field {
          Core.fieldName = (Core.Name "inputs"),
          Core.fieldTerm = (Typed.unTypedTerm inputs)},
        Core.Field {
          Core.fieldName = (Core.Name "outputs"),
          Core.fieldTerm = (Typed.unTypedTerm outputs)}]}))

-- | DSL accessor for the dependencyHashes field of hydra.build.format.OutputDigest
outputDigestDependencyHashes :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (M.Map Packaging.PackageName Format.Sha256Hash)
outputDigestDependencyHashes x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
        Core.projectionFieldName = (Core.Name "dependencyHashes")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the digestFormatVersion field of hydra.build.format.OutputDigest
outputDigestDigestFormatVersion :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm Int
outputDigestDigestFormatVersion x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
        Core.projectionFieldName = (Core.Name "digestFormatVersion")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the generation field of hydra.build.format.OutputDigest
outputDigestGeneration :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm Format.Generation
outputDigestGeneration x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
        Core.projectionFieldName = (Core.Name "generation")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the generator field of hydra.build.format.OutputDigest
outputDigestGenerator :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm String
outputDigestGenerator x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
        Core.projectionFieldName = (Core.Name "generator")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the inputs field of hydra.build.format.OutputDigest
outputDigestInputs :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (M.Map String Format.DigestEntry)
outputDigestInputs x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
        Core.projectionFieldName = (Core.Name "inputs")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the moduleFormatVersion field of hydra.build.format.OutputDigest
outputDigestModuleFormatVersion :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm Int
outputDigestModuleFormatVersion x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
        Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.build.format.OutputDigest
outputDigestOutputDigest :: Typed.TypedName Format.OutputDigest
outputDigestOutputDigest = Typed.TypedName (Core.Name "hydra.build.format.OutputDigest")

-- | DSL accessor for the outputs field of hydra.build.format.OutputDigest
outputDigestOutputs :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (M.Map String Format.DigestEntry)
outputDigestOutputs x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
        Core.projectionFieldName = (Core.Name "outputs")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the selfHash field of hydra.build.format.OutputDigest
outputDigestSelfHash :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (Maybe Format.Sha256Hash)
outputDigestSelfHash x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
        Core.projectionFieldName = (Core.Name "selfHash")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the dependencyHashes field of hydra.build.format.OutputDigest
outputDigestWithDependencyHashes :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (M.Map Packaging.PackageName Format.Sha256Hash) -> Typed.TypedTerm Format.OutputDigest
outputDigestWithDependencyHashes original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.OutputDigest"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "digestFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "digestFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "moduleFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "generator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "generator")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "generation"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "generation")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "selfHash"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "selfHash")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "dependencyHashes"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "inputs"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "inputs")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "outputs"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "outputs")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the digestFormatVersion field of hydra.build.format.OutputDigest
outputDigestWithDigestFormatVersion :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm Int -> Typed.TypedTerm Format.OutputDigest
outputDigestWithDigestFormatVersion original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.OutputDigest"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "digestFormatVersion"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "moduleFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "generator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "generator")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "generation"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "generation")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "selfHash"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "selfHash")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "dependencyHashes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "dependencyHashes")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "inputs"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "inputs")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "outputs"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "outputs")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the generation field of hydra.build.format.OutputDigest
outputDigestWithGeneration :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm Format.Generation -> Typed.TypedTerm Format.OutputDigest
outputDigestWithGeneration original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.OutputDigest"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "digestFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "digestFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "moduleFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "generator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "generator")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "generation"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "selfHash"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "selfHash")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "dependencyHashes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "dependencyHashes")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "inputs"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "inputs")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "outputs"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "outputs")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the generator field of hydra.build.format.OutputDigest
outputDigestWithGenerator :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm String -> Typed.TypedTerm Format.OutputDigest
outputDigestWithGenerator original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.OutputDigest"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "digestFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "digestFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "moduleFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "generator"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "generation"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "generation")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "selfHash"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "selfHash")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "dependencyHashes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "dependencyHashes")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "inputs"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "inputs")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "outputs"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "outputs")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the inputs field of hydra.build.format.OutputDigest
outputDigestWithInputs :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (M.Map String Format.DigestEntry) -> Typed.TypedTerm Format.OutputDigest
outputDigestWithInputs original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.OutputDigest"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "digestFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "digestFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "moduleFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "generator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "generator")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "generation"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "generation")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "selfHash"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "selfHash")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "dependencyHashes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "dependencyHashes")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "inputs"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "outputs"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "outputs")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the moduleFormatVersion field of hydra.build.format.OutputDigest
outputDigestWithModuleFormatVersion :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm Int -> Typed.TypedTerm Format.OutputDigest
outputDigestWithModuleFormatVersion original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.OutputDigest"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "digestFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "digestFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "moduleFormatVersion"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "generator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "generator")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "generation"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "generation")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "selfHash"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "selfHash")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "dependencyHashes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "dependencyHashes")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "inputs"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "inputs")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "outputs"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "outputs")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the outputs field of hydra.build.format.OutputDigest
outputDigestWithOutputs :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (M.Map String Format.DigestEntry) -> Typed.TypedTerm Format.OutputDigest
outputDigestWithOutputs original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.OutputDigest"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "digestFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "digestFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "moduleFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "generator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "generator")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "generation"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "generation")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "selfHash"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "selfHash")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "dependencyHashes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "dependencyHashes")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "inputs"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "inputs")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "outputs"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the selfHash field of hydra.build.format.OutputDigest
outputDigestWithSelfHash :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (Maybe Format.Sha256Hash) -> Typed.TypedTerm Format.OutputDigest
outputDigestWithSelfHash original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.OutputDigest"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "digestFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "digestFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "moduleFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "generator"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "generator")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "generation"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "generation")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "selfHash"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "dependencyHashes"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "dependencyHashes")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "inputs"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "inputs")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "outputs"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),
              Core.projectionFieldName = (Core.Name "outputs")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.build.format.PackageDescriptor
packageDescriptor :: Typed.TypedTerm Int -> Typed.TypedTerm Packaging.PackageName -> Typed.TypedTerm String -> Typed.TypedTerm Format.LanguageName -> Typed.TypedTerm (Maybe [Format.LanguageName]) -> Typed.TypedTerm [Packaging.PackageName] -> Typed.TypedTerm (Maybe Format.PackageValidationConfiguration) -> Typed.TypedTerm Format.PackageDescriptor
packageDescriptor packageFormatVersion name description sourceLanguage targetLanguages dependencies validation =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "packageFormatVersion"),
          Core.fieldTerm = (Typed.unTypedTerm packageFormatVersion)},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Typed.unTypedTerm name)},
        Core.Field {
          Core.fieldName = (Core.Name "description"),
          Core.fieldTerm = (Typed.unTypedTerm description)},
        Core.Field {
          Core.fieldName = (Core.Name "sourceLanguage"),
          Core.fieldTerm = (Typed.unTypedTerm sourceLanguage)},
        Core.Field {
          Core.fieldName = (Core.Name "targetLanguages"),
          Core.fieldTerm = (Typed.unTypedTerm targetLanguages)},
        Core.Field {
          Core.fieldName = (Core.Name "dependencies"),
          Core.fieldTerm = (Typed.unTypedTerm dependencies)},
        Core.Field {
          Core.fieldName = (Core.Name "validation"),
          Core.fieldTerm = (Typed.unTypedTerm validation)}]}))

-- | DSL accessor for the dependencies field of hydra.build.format.PackageDescriptor
packageDescriptorDependencies :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm [Packaging.PackageName]
packageDescriptorDependencies x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
        Core.projectionFieldName = (Core.Name "dependencies")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the description field of hydra.build.format.PackageDescriptor
packageDescriptorDescription :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm String
packageDescriptorDescription x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
        Core.projectionFieldName = (Core.Name "description")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the name field of hydra.build.format.PackageDescriptor
packageDescriptorName :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm Packaging.PackageName
packageDescriptorName x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
        Core.projectionFieldName = (Core.Name "name")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.build.format.PackageDescriptor
packageDescriptorPackageDescriptor :: Typed.TypedName Format.PackageDescriptor
packageDescriptorPackageDescriptor = Typed.TypedName (Core.Name "hydra.build.format.PackageDescriptor")

-- | DSL accessor for the packageFormatVersion field of hydra.build.format.PackageDescriptor
packageDescriptorPackageFormatVersion :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm Int
packageDescriptorPackageFormatVersion x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
        Core.projectionFieldName = (Core.Name "packageFormatVersion")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the sourceLanguage field of hydra.build.format.PackageDescriptor
packageDescriptorSourceLanguage :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm Format.LanguageName
packageDescriptorSourceLanguage x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
        Core.projectionFieldName = (Core.Name "sourceLanguage")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the targetLanguages field of hydra.build.format.PackageDescriptor
packageDescriptorTargetLanguages :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm (Maybe [Format.LanguageName])
packageDescriptorTargetLanguages x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
        Core.projectionFieldName = (Core.Name "targetLanguages")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the validation field of hydra.build.format.PackageDescriptor
packageDescriptorValidation :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm (Maybe Format.PackageValidationConfiguration)
packageDescriptorValidation x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
        Core.projectionFieldName = (Core.Name "validation")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the dependencies field of hydra.build.format.PackageDescriptor
packageDescriptorWithDependencies :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm [Packaging.PackageName] -> Typed.TypedTerm Format.PackageDescriptor
packageDescriptorWithDependencies original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "packageFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "packageFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "name")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "description"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "description")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "sourceLanguage"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "sourceLanguage")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "targetLanguages"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "targetLanguages")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "dependencies"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "validation"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "validation")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the description field of hydra.build.format.PackageDescriptor
packageDescriptorWithDescription :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm String -> Typed.TypedTerm Format.PackageDescriptor
packageDescriptorWithDescription original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "packageFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "packageFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "name")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "description"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "sourceLanguage"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "sourceLanguage")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "targetLanguages"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "targetLanguages")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "dependencies"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "dependencies")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "validation"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "validation")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.build.format.PackageDescriptor
packageDescriptorWithName :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm Packaging.PackageName -> Typed.TypedTerm Format.PackageDescriptor
packageDescriptorWithName original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "packageFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "packageFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "description"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "description")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "sourceLanguage"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "sourceLanguage")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "targetLanguages"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "targetLanguages")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "dependencies"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "dependencies")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "validation"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "validation")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the packageFormatVersion field of hydra.build.format.PackageDescriptor
packageDescriptorWithPackageFormatVersion :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm Int -> Typed.TypedTerm Format.PackageDescriptor
packageDescriptorWithPackageFormatVersion original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "packageFormatVersion"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "name")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "description"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "description")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "sourceLanguage"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "sourceLanguage")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "targetLanguages"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "targetLanguages")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "dependencies"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "dependencies")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "validation"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "validation")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the sourceLanguage field of hydra.build.format.PackageDescriptor
packageDescriptorWithSourceLanguage :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm Format.LanguageName -> Typed.TypedTerm Format.PackageDescriptor
packageDescriptorWithSourceLanguage original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "packageFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "packageFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "name")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "description"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "description")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "sourceLanguage"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "targetLanguages"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "targetLanguages")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "dependencies"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "dependencies")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "validation"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "validation")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the targetLanguages field of hydra.build.format.PackageDescriptor
packageDescriptorWithTargetLanguages :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm (Maybe [Format.LanguageName]) -> Typed.TypedTerm Format.PackageDescriptor
packageDescriptorWithTargetLanguages original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "packageFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "packageFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "name")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "description"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "description")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "sourceLanguage"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "sourceLanguage")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "targetLanguages"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "dependencies"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "dependencies")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "validation"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "validation")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the validation field of hydra.build.format.PackageDescriptor
packageDescriptorWithValidation :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm (Maybe Format.PackageValidationConfiguration) -> Typed.TypedTerm Format.PackageDescriptor
packageDescriptorWithValidation original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "packageFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "packageFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "name")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "description"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "description")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "sourceLanguage"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "sourceLanguage")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "targetLanguages"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "targetLanguages")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "dependencies"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
              Core.projectionFieldName = (Core.Name "dependencies")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "validation"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.build.format.PackageManifest
packageManifest :: Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm Packaging.PackageName -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm Format.PackageManifest
packageManifest manifestFormatVersion moduleFormatVersion package mainModules testModules mainDslModules mainEncodingModules =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.PackageManifest"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "manifestFormatVersion"),
          Core.fieldTerm = (Typed.unTypedTerm manifestFormatVersion)},
        Core.Field {
          Core.fieldName = (Core.Name "moduleFormatVersion"),
          Core.fieldTerm = (Typed.unTypedTerm moduleFormatVersion)},
        Core.Field {
          Core.fieldName = (Core.Name "package"),
          Core.fieldTerm = (Typed.unTypedTerm package)},
        Core.Field {
          Core.fieldName = (Core.Name "mainModules"),
          Core.fieldTerm = (Typed.unTypedTerm mainModules)},
        Core.Field {
          Core.fieldName = (Core.Name "testModules"),
          Core.fieldTerm = (Typed.unTypedTerm testModules)},
        Core.Field {
          Core.fieldName = (Core.Name "mainDslModules"),
          Core.fieldTerm = (Typed.unTypedTerm mainDslModules)},
        Core.Field {
          Core.fieldName = (Core.Name "mainEncodingModules"),
          Core.fieldTerm = (Typed.unTypedTerm mainEncodingModules)}]}))

-- | DSL accessor for the mainDslModules field of hydra.build.format.PackageManifest
packageManifestMainDslModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName]
packageManifestMainDslModules x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
        Core.projectionFieldName = (Core.Name "mainDslModules")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the mainEncodingModules field of hydra.build.format.PackageManifest
packageManifestMainEncodingModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName]
packageManifestMainEncodingModules x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
        Core.projectionFieldName = (Core.Name "mainEncodingModules")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the mainModules field of hydra.build.format.PackageManifest
packageManifestMainModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName]
packageManifestMainModules x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
        Core.projectionFieldName = (Core.Name "mainModules")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the manifestFormatVersion field of hydra.build.format.PackageManifest
packageManifestManifestFormatVersion :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm Int
packageManifestManifestFormatVersion x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
        Core.projectionFieldName = (Core.Name "manifestFormatVersion")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the moduleFormatVersion field of hydra.build.format.PackageManifest
packageManifestModuleFormatVersion :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm Int
packageManifestModuleFormatVersion x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
        Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the package field of hydra.build.format.PackageManifest
packageManifestPackage :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm Packaging.PackageName
packageManifestPackage x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
        Core.projectionFieldName = (Core.Name "package")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.build.format.PackageManifest
packageManifestPackageManifest :: Typed.TypedName Format.PackageManifest
packageManifestPackageManifest = Typed.TypedName (Core.Name "hydra.build.format.PackageManifest")

-- | DSL accessor for the testModules field of hydra.build.format.PackageManifest
packageManifestTestModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName]
packageManifestTestModules x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
        Core.projectionFieldName = (Core.Name "testModules")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the mainDslModules field of hydra.build.format.PackageManifest
packageManifestWithMainDslModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm Format.PackageManifest
packageManifestWithMainDslModules original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.PackageManifest"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "manifestFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "manifestFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "moduleFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "package"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "package")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "mainModules"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "mainModules")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "testModules"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "testModules")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "mainDslModules"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "mainEncodingModules"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "mainEncodingModules")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the mainEncodingModules field of hydra.build.format.PackageManifest
packageManifestWithMainEncodingModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm Format.PackageManifest
packageManifestWithMainEncodingModules original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.PackageManifest"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "manifestFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "manifestFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "moduleFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "package"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "package")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "mainModules"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "mainModules")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "testModules"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "testModules")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "mainDslModules"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "mainDslModules")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "mainEncodingModules"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the mainModules field of hydra.build.format.PackageManifest
packageManifestWithMainModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm Format.PackageManifest
packageManifestWithMainModules original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.PackageManifest"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "manifestFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "manifestFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "moduleFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "package"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "package")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "mainModules"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "testModules"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "testModules")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "mainDslModules"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "mainDslModules")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "mainEncodingModules"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "mainEncodingModules")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the manifestFormatVersion field of hydra.build.format.PackageManifest
packageManifestWithManifestFormatVersion :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm Int -> Typed.TypedTerm Format.PackageManifest
packageManifestWithManifestFormatVersion original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.PackageManifest"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "manifestFormatVersion"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "moduleFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "package"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "package")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "mainModules"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "mainModules")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "testModules"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "testModules")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "mainDslModules"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "mainDslModules")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "mainEncodingModules"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "mainEncodingModules")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the moduleFormatVersion field of hydra.build.format.PackageManifest
packageManifestWithModuleFormatVersion :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm Int -> Typed.TypedTerm Format.PackageManifest
packageManifestWithModuleFormatVersion original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.PackageManifest"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "manifestFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "manifestFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "moduleFormatVersion"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "package"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "package")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "mainModules"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "mainModules")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "testModules"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "testModules")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "mainDslModules"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "mainDslModules")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "mainEncodingModules"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "mainEncodingModules")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the package field of hydra.build.format.PackageManifest
packageManifestWithPackage :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm Packaging.PackageName -> Typed.TypedTerm Format.PackageManifest
packageManifestWithPackage original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.PackageManifest"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "manifestFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "manifestFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "moduleFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "package"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "mainModules"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "mainModules")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "testModules"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "testModules")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "mainDslModules"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "mainDslModules")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "mainEncodingModules"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "mainEncodingModules")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the testModules field of hydra.build.format.PackageManifest
packageManifestWithTestModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm Format.PackageManifest
packageManifestWithTestModules original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.PackageManifest"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "manifestFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "manifestFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "moduleFormatVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "package"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "package")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "mainModules"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "mainModules")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "testModules"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "mainDslModules"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "mainDslModules")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "mainEncodingModules"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),
              Core.projectionFieldName = (Core.Name "mainEncodingModules")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.build.format.PackageValidationConfiguration
packageValidationConfiguration :: Typed.TypedTerm (Maybe Format.PackageValidationProfile) -> Typed.TypedTerm (Maybe Format.ModuleValidationProfile) -> Typed.TypedTerm (Maybe Format.TypeValidationProfile) -> Typed.TypedTerm (Maybe Format.TermValidationProfile) -> Typed.TypedTerm Format.PackageValidationConfiguration
packageValidationConfiguration package module_ type_ term =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "package"),
          Core.fieldTerm = (Typed.unTypedTerm package)},
        Core.Field {
          Core.fieldName = (Core.Name "module"),
          Core.fieldTerm = (Typed.unTypedTerm module_)},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Typed.unTypedTerm type_)},
        Core.Field {
          Core.fieldName = (Core.Name "term"),
          Core.fieldTerm = (Typed.unTypedTerm term)}]}))

-- | DSL accessor for the module field of hydra.build.format.PackageValidationConfiguration
packageValidationConfigurationModule :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.ModuleValidationProfile)
packageValidationConfigurationModule x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),
        Core.projectionFieldName = (Core.Name "module")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the package field of hydra.build.format.PackageValidationConfiguration
packageValidationConfigurationPackage :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.PackageValidationProfile)
packageValidationConfigurationPackage x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),
        Core.projectionFieldName = (Core.Name "package")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.build.format.PackageValidationConfiguration
packageValidationConfigurationPackageValidationConfiguration :: Typed.TypedName Format.PackageValidationConfiguration
packageValidationConfigurationPackageValidationConfiguration =
    Typed.TypedName (Core.Name "hydra.build.format.PackageValidationConfiguration")

-- | DSL accessor for the term field of hydra.build.format.PackageValidationConfiguration
packageValidationConfigurationTerm :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.TermValidationProfile)
packageValidationConfigurationTerm x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),
        Core.projectionFieldName = (Core.Name "term")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.build.format.PackageValidationConfiguration
packageValidationConfigurationType :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.TypeValidationProfile)
packageValidationConfigurationType x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),
        Core.projectionFieldName = (Core.Name "type")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the module field of hydra.build.format.PackageValidationConfiguration
packageValidationConfigurationWithModule :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.ModuleValidationProfile) -> Typed.TypedTerm Format.PackageValidationConfiguration
packageValidationConfigurationWithModule original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "package"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),
              Core.projectionFieldName = (Core.Name "package")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "module"),
          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.build.format.PackageValidationConfiguration"),
              Core.projectionFieldName = (Core.Name "type")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "term"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),
              Core.projectionFieldName = (Core.Name "term")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the package field of hydra.build.format.PackageValidationConfiguration
packageValidationConfigurationWithPackage :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.PackageValidationProfile) -> Typed.TypedTerm Format.PackageValidationConfiguration
packageValidationConfigurationWithPackage original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "package"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "module"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),
              Core.projectionFieldName = (Core.Name "module")})),
            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.build.format.PackageValidationConfiguration"),
              Core.projectionFieldName = (Core.Name "type")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "term"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),
              Core.projectionFieldName = (Core.Name "term")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the term field of hydra.build.format.PackageValidationConfiguration
packageValidationConfigurationWithTerm :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.TermValidationProfile) -> Typed.TypedTerm Format.PackageValidationConfiguration
packageValidationConfigurationWithTerm original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "package"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),
              Core.projectionFieldName = (Core.Name "package")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "module"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),
              Core.projectionFieldName = (Core.Name "module")})),
            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.build.format.PackageValidationConfiguration"),
              Core.projectionFieldName = (Core.Name "type")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "term"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the type field of hydra.build.format.PackageValidationConfiguration
packageValidationConfigurationWithType :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.TypeValidationProfile) -> Typed.TypedTerm Format.PackageValidationConfiguration
packageValidationConfigurationWithType original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "package"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),
              Core.projectionFieldName = (Core.Name "package")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "module"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),
              Core.projectionFieldName = (Core.Name "module")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "term"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),
              Core.projectionFieldName = (Core.Name "term")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.build.format.PackageValidationProfile
packageValidationProfile :: Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.PackageValidationProfile
packageValidationProfile conflictingModuleName duplicateModuleName nameConvention =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "conflictingModuleName"),
          Core.fieldTerm = (Typed.unTypedTerm conflictingModuleName)},
        Core.Field {
          Core.fieldName = (Core.Name "duplicateModuleName"),
          Core.fieldTerm = (Typed.unTypedTerm duplicateModuleName)},
        Core.Field {
          Core.fieldName = (Core.Name "nameConvention"),
          Core.fieldTerm = (Typed.unTypedTerm nameConvention)}]}))

-- | DSL accessor for the conflictingModuleName field of hydra.build.format.PackageValidationProfile
packageValidationProfileConflictingModuleName :: Typed.TypedTerm Format.PackageValidationProfile -> Typed.TypedTerm (Maybe Format.Severity)
packageValidationProfileConflictingModuleName x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"),
        Core.projectionFieldName = (Core.Name "conflictingModuleName")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the duplicateModuleName field of hydra.build.format.PackageValidationProfile
packageValidationProfileDuplicateModuleName :: Typed.TypedTerm Format.PackageValidationProfile -> Typed.TypedTerm (Maybe Format.Severity)
packageValidationProfileDuplicateModuleName x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"),
        Core.projectionFieldName = (Core.Name "duplicateModuleName")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the nameConvention field of hydra.build.format.PackageValidationProfile
packageValidationProfileNameConvention :: Typed.TypedTerm Format.PackageValidationProfile -> Typed.TypedTerm (Maybe Format.Severity)
packageValidationProfileNameConvention x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"),
        Core.projectionFieldName = (Core.Name "nameConvention")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.build.format.PackageValidationProfile
packageValidationProfilePackageValidationProfile :: Typed.TypedName Format.PackageValidationProfile
packageValidationProfilePackageValidationProfile =
    Typed.TypedName (Core.Name "hydra.build.format.PackageValidationProfile")

-- | DSL updater for the conflictingModuleName field of hydra.build.format.PackageValidationProfile
packageValidationProfileWithConflictingModuleName :: Typed.TypedTerm Format.PackageValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.PackageValidationProfile
packageValidationProfileWithConflictingModuleName original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "conflictingModuleName"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "duplicateModuleName"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"),
              Core.projectionFieldName = (Core.Name "duplicateModuleName")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "nameConvention"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"),
              Core.projectionFieldName = (Core.Name "nameConvention")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the duplicateModuleName field of hydra.build.format.PackageValidationProfile
packageValidationProfileWithDuplicateModuleName :: Typed.TypedTerm Format.PackageValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.PackageValidationProfile
packageValidationProfileWithDuplicateModuleName original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "conflictingModuleName"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"),
              Core.projectionFieldName = (Core.Name "conflictingModuleName")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "duplicateModuleName"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "nameConvention"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"),
              Core.projectionFieldName = (Core.Name "nameConvention")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the nameConvention field of hydra.build.format.PackageValidationProfile
packageValidationProfileWithNameConvention :: Typed.TypedTerm Format.PackageValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.PackageValidationProfile
packageValidationProfileWithNameConvention original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "conflictingModuleName"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"),
              Core.projectionFieldName = (Core.Name "conflictingModuleName")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "duplicateModuleName"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"),
              Core.projectionFieldName = (Core.Name "duplicateModuleName")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "nameConvention"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.build.format.RepositoryDescriptor
repositoryDescriptor :: Typed.TypedTerm Packaging.Version -> Typed.TypedTerm Packaging.Version -> Typed.TypedTerm (M.Map Format.LanguageName Format.HostOverride) -> Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm [Packaging.PackageName] -> Typed.TypedTerm Format.RepositoryDescriptor
repositoryDescriptor currentVersion hostVersion hostOverrides group author url license packages =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "currentVersion"),
          Core.fieldTerm = (Typed.unTypedTerm currentVersion)},
        Core.Field {
          Core.fieldName = (Core.Name "hostVersion"),
          Core.fieldTerm = (Typed.unTypedTerm hostVersion)},
        Core.Field {
          Core.fieldName = (Core.Name "hostOverrides"),
          Core.fieldTerm = (Typed.unTypedTerm hostOverrides)},
        Core.Field {
          Core.fieldName = (Core.Name "group"),
          Core.fieldTerm = (Typed.unTypedTerm group)},
        Core.Field {
          Core.fieldName = (Core.Name "author"),
          Core.fieldTerm = (Typed.unTypedTerm author)},
        Core.Field {
          Core.fieldName = (Core.Name "url"),
          Core.fieldTerm = (Typed.unTypedTerm url)},
        Core.Field {
          Core.fieldName = (Core.Name "license"),
          Core.fieldTerm = (Typed.unTypedTerm license)},
        Core.Field {
          Core.fieldName = (Core.Name "packages"),
          Core.fieldTerm = (Typed.unTypedTerm packages)}]}))

-- | DSL accessor for the author field of hydra.build.format.RepositoryDescriptor
repositoryDescriptorAuthor :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String
repositoryDescriptorAuthor x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
        Core.projectionFieldName = (Core.Name "author")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the currentVersion field of hydra.build.format.RepositoryDescriptor
repositoryDescriptorCurrentVersion :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm Packaging.Version
repositoryDescriptorCurrentVersion x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
        Core.projectionFieldName = (Core.Name "currentVersion")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the group field of hydra.build.format.RepositoryDescriptor
repositoryDescriptorGroup :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String
repositoryDescriptorGroup x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
        Core.projectionFieldName = (Core.Name "group")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the hostOverrides field of hydra.build.format.RepositoryDescriptor
repositoryDescriptorHostOverrides :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm (M.Map Format.LanguageName Format.HostOverride)
repositoryDescriptorHostOverrides x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
        Core.projectionFieldName = (Core.Name "hostOverrides")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the hostVersion field of hydra.build.format.RepositoryDescriptor
repositoryDescriptorHostVersion :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm Packaging.Version
repositoryDescriptorHostVersion x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
        Core.projectionFieldName = (Core.Name "hostVersion")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the license field of hydra.build.format.RepositoryDescriptor
repositoryDescriptorLicense :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String
repositoryDescriptorLicense x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
        Core.projectionFieldName = (Core.Name "license")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the packages field of hydra.build.format.RepositoryDescriptor
repositoryDescriptorPackages :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm [Packaging.PackageName]
repositoryDescriptorPackages x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
        Core.projectionFieldName = (Core.Name "packages")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.build.format.RepositoryDescriptor
repositoryDescriptorRepositoryDescriptor :: Typed.TypedName Format.RepositoryDescriptor
repositoryDescriptorRepositoryDescriptor = Typed.TypedName (Core.Name "hydra.build.format.RepositoryDescriptor")

-- | DSL accessor for the url field of hydra.build.format.RepositoryDescriptor
repositoryDescriptorUrl :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String
repositoryDescriptorUrl x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
        Core.projectionFieldName = (Core.Name "url")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the author field of hydra.build.format.RepositoryDescriptor
repositoryDescriptorWithAuthor :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String -> Typed.TypedTerm Format.RepositoryDescriptor
repositoryDescriptorWithAuthor original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "currentVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "currentVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "hostVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "hostVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "hostOverrides"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "hostOverrides")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "group"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "group")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "author"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "url"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "url")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "license"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "license")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "packages"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "packages")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the currentVersion field of hydra.build.format.RepositoryDescriptor
repositoryDescriptorWithCurrentVersion :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm Packaging.Version -> Typed.TypedTerm Format.RepositoryDescriptor
repositoryDescriptorWithCurrentVersion original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "currentVersion"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "hostVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "hostVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "hostOverrides"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "hostOverrides")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "group"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "group")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "author"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "author")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "url"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "url")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "license"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "license")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "packages"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "packages")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the group field of hydra.build.format.RepositoryDescriptor
repositoryDescriptorWithGroup :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String -> Typed.TypedTerm Format.RepositoryDescriptor
repositoryDescriptorWithGroup original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "currentVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "currentVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "hostVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "hostVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "hostOverrides"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "hostOverrides")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "group"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "author"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "author")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "url"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "url")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "license"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "license")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "packages"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "packages")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the hostOverrides field of hydra.build.format.RepositoryDescriptor
repositoryDescriptorWithHostOverrides :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm (M.Map Format.LanguageName Format.HostOverride) -> Typed.TypedTerm Format.RepositoryDescriptor
repositoryDescriptorWithHostOverrides original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "currentVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "currentVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "hostVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "hostVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "hostOverrides"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "group"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "group")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "author"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "author")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "url"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "url")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "license"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "license")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "packages"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "packages")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the hostVersion field of hydra.build.format.RepositoryDescriptor
repositoryDescriptorWithHostVersion :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm Packaging.Version -> Typed.TypedTerm Format.RepositoryDescriptor
repositoryDescriptorWithHostVersion original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "currentVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "currentVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "hostVersion"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "hostOverrides"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "hostOverrides")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "group"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "group")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "author"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "author")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "url"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "url")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "license"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "license")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "packages"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "packages")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the license field of hydra.build.format.RepositoryDescriptor
repositoryDescriptorWithLicense :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String -> Typed.TypedTerm Format.RepositoryDescriptor
repositoryDescriptorWithLicense original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "currentVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "currentVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "hostVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "hostVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "hostOverrides"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "hostOverrides")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "group"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "group")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "author"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "author")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "url"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "url")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "license"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "packages"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "packages")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the packages field of hydra.build.format.RepositoryDescriptor
repositoryDescriptorWithPackages :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm [Packaging.PackageName] -> Typed.TypedTerm Format.RepositoryDescriptor
repositoryDescriptorWithPackages original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "currentVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "currentVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "hostVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "hostVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "hostOverrides"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "hostOverrides")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "group"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "group")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "author"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "author")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "url"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "url")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "license"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "license")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "packages"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the url field of hydra.build.format.RepositoryDescriptor
repositoryDescriptorWithUrl :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String -> Typed.TypedTerm Format.RepositoryDescriptor
repositoryDescriptorWithUrl original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "currentVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "currentVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "hostVersion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "hostVersion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "hostOverrides"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "hostOverrides")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "group"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "group")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "author"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "author")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "url"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "license"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "license")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "packages"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
              Core.projectionFieldName = (Core.Name "packages")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the error variant of hydra.build.format.Severity
severityError :: Typed.TypedTerm Format.Severity
severityError =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.build.format.Severity"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "error"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL name token for hydra.build.format.Severity
severitySeverity :: Typed.TypedName Format.Severity
severitySeverity = Typed.TypedName (Core.Name "hydra.build.format.Severity")

-- | DSL injection for the warning variant of hydra.build.format.Severity
severityWarning :: Typed.TypedTerm Format.Severity
severityWarning =
    Typed.TypedTerm (Core.TermInject (Core.Injection {
      Core.injectionTypeName = (Core.Name "hydra.build.format.Severity"),
      Core.injectionField = Core.Field {
        Core.fieldName = (Core.Name "warning"),
        Core.fieldTerm = Core.TermUnit}}))

-- | DSL constructor for the hydra.build.format.Sha256Hash wrapper
sha256Hash :: Typed.TypedTerm String -> Typed.TypedTerm Format.Sha256Hash
sha256Hash x =
    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.build.format.Sha256Hash"),
      Core.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.build.format.Sha256Hash
sha256HashSha256Hash :: Typed.TypedName Format.Sha256Hash
sha256HashSha256Hash = Typed.TypedName (Core.Name "hydra.build.format.Sha256Hash")

-- | DSL constructor for hydra.build.format.TermValidationProfile
termValidationProfile :: Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TermValidationProfile
termValidationProfile duplicateBinding emptyTermAnnotation undefinedVariable =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.TermValidationProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "duplicateBinding"),
          Core.fieldTerm = (Typed.unTypedTerm duplicateBinding)},
        Core.Field {
          Core.fieldName = (Core.Name "emptyTermAnnotation"),
          Core.fieldTerm = (Typed.unTypedTerm emptyTermAnnotation)},
        Core.Field {
          Core.fieldName = (Core.Name "undefinedVariable"),
          Core.fieldTerm = (Typed.unTypedTerm undefinedVariable)}]}))

-- | DSL accessor for the duplicateBinding field of hydra.build.format.TermValidationProfile
termValidationProfileDuplicateBinding :: Typed.TypedTerm Format.TermValidationProfile -> Typed.TypedTerm (Maybe Format.Severity)
termValidationProfileDuplicateBinding x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.TermValidationProfile"),
        Core.projectionFieldName = (Core.Name "duplicateBinding")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the emptyTermAnnotation field of hydra.build.format.TermValidationProfile
termValidationProfileEmptyTermAnnotation :: Typed.TypedTerm Format.TermValidationProfile -> Typed.TypedTerm (Maybe Format.Severity)
termValidationProfileEmptyTermAnnotation x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.TermValidationProfile"),
        Core.projectionFieldName = (Core.Name "emptyTermAnnotation")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.build.format.TermValidationProfile
termValidationProfileTermValidationProfile :: Typed.TypedName Format.TermValidationProfile
termValidationProfileTermValidationProfile = Typed.TypedName (Core.Name "hydra.build.format.TermValidationProfile")

-- | DSL accessor for the undefinedVariable field of hydra.build.format.TermValidationProfile
termValidationProfileUndefinedVariable :: Typed.TypedTerm Format.TermValidationProfile -> Typed.TypedTerm (Maybe Format.Severity)
termValidationProfileUndefinedVariable x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.TermValidationProfile"),
        Core.projectionFieldName = (Core.Name "undefinedVariable")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the duplicateBinding field of hydra.build.format.TermValidationProfile
termValidationProfileWithDuplicateBinding :: Typed.TypedTerm Format.TermValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TermValidationProfile
termValidationProfileWithDuplicateBinding original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.TermValidationProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "duplicateBinding"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "emptyTermAnnotation"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.TermValidationProfile"),
              Core.projectionFieldName = (Core.Name "emptyTermAnnotation")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "undefinedVariable"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.TermValidationProfile"),
              Core.projectionFieldName = (Core.Name "undefinedVariable")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the emptyTermAnnotation field of hydra.build.format.TermValidationProfile
termValidationProfileWithEmptyTermAnnotation :: Typed.TypedTerm Format.TermValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TermValidationProfile
termValidationProfileWithEmptyTermAnnotation original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.TermValidationProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "duplicateBinding"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.TermValidationProfile"),
              Core.projectionFieldName = (Core.Name "duplicateBinding")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "emptyTermAnnotation"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "undefinedVariable"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.TermValidationProfile"),
              Core.projectionFieldName = (Core.Name "undefinedVariable")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the undefinedVariable field of hydra.build.format.TermValidationProfile
termValidationProfileWithUndefinedVariable :: Typed.TypedTerm Format.TermValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TermValidationProfile
termValidationProfileWithUndefinedVariable original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.TermValidationProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "duplicateBinding"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.TermValidationProfile"),
              Core.projectionFieldName = (Core.Name "duplicateBinding")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "emptyTermAnnotation"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.TermValidationProfile"),
              Core.projectionFieldName = (Core.Name "emptyTermAnnotation")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "undefinedVariable"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.build.format.TypeValidationProfile
typeValidationProfile :: Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TypeValidationProfile
typeValidationProfile emptyAnnotation duplicateField singleVariantUnion =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "emptyAnnotation"),
          Core.fieldTerm = (Typed.unTypedTerm emptyAnnotation)},
        Core.Field {
          Core.fieldName = (Core.Name "duplicateField"),
          Core.fieldTerm = (Typed.unTypedTerm duplicateField)},
        Core.Field {
          Core.fieldName = (Core.Name "singleVariantUnion"),
          Core.fieldTerm = (Typed.unTypedTerm singleVariantUnion)}]}))

-- | DSL accessor for the duplicateField field of hydra.build.format.TypeValidationProfile
typeValidationProfileDuplicateField :: Typed.TypedTerm Format.TypeValidationProfile -> Typed.TypedTerm (Maybe Format.Severity)
typeValidationProfileDuplicateField x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"),
        Core.projectionFieldName = (Core.Name "duplicateField")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the emptyAnnotation field of hydra.build.format.TypeValidationProfile
typeValidationProfileEmptyAnnotation :: Typed.TypedTerm Format.TypeValidationProfile -> Typed.TypedTerm (Maybe Format.Severity)
typeValidationProfileEmptyAnnotation x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"),
        Core.projectionFieldName = (Core.Name "emptyAnnotation")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the singleVariantUnion field of hydra.build.format.TypeValidationProfile
typeValidationProfileSingleVariantUnion :: Typed.TypedTerm Format.TypeValidationProfile -> Typed.TypedTerm (Maybe Format.Severity)
typeValidationProfileSingleVariantUnion x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermProject (Core.Projection {
        Core.projectionTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"),
        Core.projectionFieldName = (Core.Name "singleVariantUnion")})),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.build.format.TypeValidationProfile
typeValidationProfileTypeValidationProfile :: Typed.TypedName Format.TypeValidationProfile
typeValidationProfileTypeValidationProfile = Typed.TypedName (Core.Name "hydra.build.format.TypeValidationProfile")

-- | DSL updater for the duplicateField field of hydra.build.format.TypeValidationProfile
typeValidationProfileWithDuplicateField :: Typed.TypedTerm Format.TypeValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TypeValidationProfile
typeValidationProfileWithDuplicateField original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "emptyAnnotation"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"),
              Core.projectionFieldName = (Core.Name "emptyAnnotation")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "duplicateField"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "singleVariantUnion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"),
              Core.projectionFieldName = (Core.Name "singleVariantUnion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the emptyAnnotation field of hydra.build.format.TypeValidationProfile
typeValidationProfileWithEmptyAnnotation :: Typed.TypedTerm Format.TypeValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TypeValidationProfile
typeValidationProfileWithEmptyAnnotation original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "emptyAnnotation"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)},
        Core.Field {
          Core.fieldName = (Core.Name "duplicateField"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"),
              Core.projectionFieldName = (Core.Name "duplicateField")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "singleVariantUnion"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"),
              Core.projectionFieldName = (Core.Name "singleVariantUnion")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the singleVariantUnion field of hydra.build.format.TypeValidationProfile
typeValidationProfileWithSingleVariantUnion :: Typed.TypedTerm Format.TypeValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TypeValidationProfile
typeValidationProfileWithSingleVariantUnion original newVal =
    Typed.TypedTerm (Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "emptyAnnotation"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"),
              Core.projectionFieldName = (Core.Name "emptyAnnotation")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "duplicateField"),
          Core.fieldTerm = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermProject (Core.Projection {
              Core.projectionTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"),
              Core.projectionFieldName = (Core.Name "duplicateField")})),
            Core.applicationArgument = (Typed.unTypedTerm original)}))},
        Core.Field {
          Core.fieldName = (Core.Name "singleVariantUnion"),
          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL accessor for the body of hydra.build.format.LanguageName
unLanguageName :: Typed.TypedTerm Format.LanguageName -> Typed.TypedTerm String
unLanguageName x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.build.format.LanguageName")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.build.format.Sha256Hash
unSha256Hash :: Typed.TypedTerm Format.Sha256Hash -> Typed.TypedTerm String
unSha256Hash x =
    Typed.TypedTerm (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.build.format.Sha256Hash")),
      Core.applicationArgument = (Typed.unTypedTerm x)}))