hydra-build 0.17.7 → 0.18.0

raw patch · 44 files changed

+7709/−7593 lines, 44 filesdep ~hydra-kernelPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: hydra-kernel

API changes (from Hackage documentation)

Files

• CHANGELOG.md +80/−0
• hydra-build.cabal +14/−14
• src/main/haskell/Hydra/Build/Assembly.hs +17/−17
• src/main/haskell/Hydra/Build/Assemblyplan.hs +34/−32
• src/main/haskell/Hydra/Build/Benchresult.hs +18/−18
• src/main/haskell/Hydra/Build/Comparereport.hs +15/−15
• src/main/haskell/Hydra/Build/Comparereportlogic.hs +40/−38
• src/main/haskell/Hydra/Build/Decode/Assembly.hs +102/−0
• src/main/haskell/Hydra/Build/Decode/Benchresult.hs +123/−0
• src/main/haskell/Hydra/Build/Decode/Comparereport.hs +106/−0
• src/main/haskell/Hydra/Build/Decode/Format.hs +444/−0
• src/main/haskell/Hydra/Build/Dsl/Assembly.hs +375/−0
• src/main/haskell/Hydra/Build/Dsl/Benchresult.hs +597/−0
• src/main/haskell/Hydra/Build/Dsl/Comparereport.hs +425/−0
• src/main/haskell/Hydra/Build/Dsl/Format.hs +4108/−0
• src/main/haskell/Hydra/Build/Encode/Assembly.hs +82/−0
• src/main/haskell/Hydra/Build/Encode/Benchresult.hs +81/−0
• src/main/haskell/Hydra/Build/Encode/Comparereport.hs +70/−0
• src/main/haskell/Hydra/Build/Encode/Format.hs +429/−0
• src/main/haskell/Hydra/Build/Format.hs +107/−107
• src/main/haskell/Hydra/Build/Langexpansion.hs +35/−33
• src/main/haskell/Hydra/Build/Libraries.hs +32/−30
• src/main/haskell/Hydra/Build/ManifestWriter.hs +39/−37
• src/main/haskell/Hydra/Build/Modules.hs +40/−38
• src/main/haskell/Hydra/Build/PackagingProfile.hs +34/−32
• src/main/haskell/Hydra/Build/Publishsets.hs +37/−35
• src/main/haskell/Hydra/Build/Reconcile.hs +39/−37
• src/main/haskell/Hydra/Build/Registry.hs +36/−34
• src/main/haskell/Hydra/Build/Routing.hs +41/−39
• src/main/haskell/Hydra/Build/Syncmatrix.hs +35/−33
• src/main/haskell/Hydra/Build/Versionconsistency.hs +37/−35
• src/main/haskell/Hydra/Build/Walk.hs +37/−35
• src/main/haskell/Hydra/Decode/Build/Assembly.hs +0/−102
• src/main/haskell/Hydra/Decode/Build/Benchresult.hs +0/−123
• src/main/haskell/Hydra/Decode/Build/Comparereport.hs +0/−102
• src/main/haskell/Hydra/Decode/Build/Format.hs +0/−440
• src/main/haskell/Hydra/Dsl/Build/Assembly.hs +0/−375
• src/main/haskell/Hydra/Dsl/Build/Benchresult.hs +0/−597
• src/main/haskell/Hydra/Dsl/Build/Comparereport.hs +0/−425
• src/main/haskell/Hydra/Dsl/Build/Format.hs +0/−4108
• src/main/haskell/Hydra/Encode/Build/Assembly.hs +0/−82
• src/main/haskell/Hydra/Encode/Build/Benchresult.hs +0/−81
• src/main/haskell/Hydra/Encode/Build/Comparereport.hs +0/−70
• src/main/haskell/Hydra/Encode/Build/Format.hs +0/−429

@@ -15,6 +15,86 @@  --- +## [0.18.0] - 2026-09-29++Module-naming systematization release: every kernel and package module moves onto a uniform+`hydra.core.*` / `hydra.<pkg>.*` grammar, completing the package ⊃ module ⊃ definition containment+tower. The rename touches every module, definition, and cross-host reference in the codebase; this+release exists primarily to ship it as its own coordinated batch. Also lands the translingual regex+primitive pipeline and several silent-correctness fixes in the coder layer.++### Highlights++- **Module-name grammar systematization** ([#729](https://github.com/CategoricalData/hydra/issues/729)):+  every `hydra.*` module renamed onto a uniform package-derived prefix — kernel modules move to+  `hydra.core.*`, package modules to `hydra.<pkg>.*` — closing the long-standing inconsistency where+  a package name had no structural relationship to the module names it contained. The rename spans+  every host (Haskell, Java, Python, Scala, TypeScript, all four Lisp dialects) and required fixing+  stale namespace references, overlay-directory paths, and `hostOverrides` shims across every driver+  and bootstrap script that had hardcoded the old grammar. Further consolidation (a structurally+  enforced package↔prefix law) is tracked for 0.18.1. The kernel package itself is still published as+  `hydra-kernel` (its modules are under `hydra.core.*`); the `hydra-core` package rename #729 called for+  is under review because that name is taken on PyPI and npm+  ([#770](https://github.com/CategoricalData/hydra/issues/770)).+- **Translingual regex primitives** ([#603](https://github.com/CategoricalData/hydra/issues/603)):+  `hydra.lib.regex` primitives (`find`, `findAll`, `matches`, `replace`, `replaceAll`, `split`) now run+  every pattern through the shared `hydra.regex` parse/print pipeline instead of handing raw pattern+  strings to each host's native engine, so a pattern means the same thing on every host. Includes a+  host-independent conformance suite and a leftmost-longest alternation fix in the PCRE/POSIX printers.+- **Silent-corruption fixes across the coder layer**+  ([#744](https://github.com/CategoricalData/hydra/issues/744),+  [#765](https://github.com/CategoricalData/hydra/issues/765),+  [#649](https://github.com/CategoricalData/hydra/issues/649)): fixed data-corrupting bugs in the+  JSON-Schema/Avro/GraphQL/GraphSON/Protobuf coders (extended integer widths, map-key handling), the+  kernel's encode/decode generators (reversed type-parameter order on 2+-param polymorphic types), and+  the Python coder (silently dropping a module's types when types and terms share a file path).+- **Self-hosted specification docs** ([#723](https://github.com/CategoricalData/hydra/issues/723)):+  the module-reference pages under `docs/specification/` are now generated directly from the kernel+  (`bin/regenerate-spec.sh`) via a new metadata-only doc coder, rather than hand-maintained.++### New features++- **[#603](https://github.com/CategoricalData/hydra/issues/603)** host-independent regex conformance+  suite covering the minimal-core grammar (literals, classes, quantifiers, alternation, anchors,+  grouping) across all 9 hosts.+- **[#723](https://github.com/CategoricalData/hydra/issues/723)** `hydra.markdown` type module and+  `generateModuleDoc`, the metadata-only doc coder backing the self-generated spec pages.+- **[#382](https://github.com/CategoricalData/hydra/issues/382)** the Rust coder is split out of+  `hydra-ext` into its own first-class `hydra-rust` package.++### Bug fixes++- **[#744](https://github.com/CategoricalData/hydra/issues/744)** silent data corruption in+  JSON-Schema/Avro/GraphQL/GraphSON/Protobuf coders for extended integer widths and map-key handling.+- **[#765](https://github.com/CategoricalData/hydra/issues/765)** kernel encode/decode generators+  emitted reversed type-parameter order for 2+-param polymorphic types.+- **[#649](https://github.com/CategoricalData/hydra/issues/649)** Python coder silently dropped a+  module's types when types and terms targeted the same output file path.+- **[#572](https://github.com/CategoricalData/hydra/issues/572)** TypeScript kernel-JSON test+  bridge's compact-form decode heuristic mishandled nullary union arms.+- **[#761](https://github.com/CategoricalData/hydra/issues/761)** cold-seed generation ignored+  `hostOverrides.java=local`, silently pulling the published Java host jar instead.+- **[#736](https://github.com/CategoricalData/hydra/issues/736)** Java build now pins JDK 11 via a+  Gradle toolchain block, instead of depending on ambient `JAVA_HOME`.++### Improvements++- **[#327](https://github.com/CategoricalData/hydra/issues/327)** new `hydra.diff` schema-diff type+  module; `Term.Inject` comparison is now by variant name.+- **[#573](https://github.com/CategoricalData/hydra/issues/573)** per-registry publish sets (Hackage,+  Maven, PyPI, npm) are now derived from the package registry itself instead of 13 hand-maintained+  lists — closes a recurring class of silent release-time drift.+- **[#735](https://github.com/CategoricalData/hydra/issues/735)** cross-host decimal-scale test+  filtering now driven by a translingual `scaleDistinct` capability tag instead of hand-copied+  per-host skip lists.++### Documentation++- **[#655](https://github.com/CategoricalData/hydra/issues/655)** documented the overlay-emission+  "implementation wins" decision for bare primitive references (`docs/overlays.md`).++---+ ## [0.17.7] - 2026-09-14  Correctness-hardening point release on the 0.17.x line, consolidating the 0.17.6 breaking batch. It

@@ -5,7 +5,7 @@ -- see: https://github.com/sol/hpack  name:           hydra-build-version:        0.17.7+version:        0.18.0 synopsis:       Hydra's build system, promoted into Hydra description:    Hydra is an implementation of the LambdaGraph data model, which takes advantage of an isomorphism between labeled hypergraphs and typed lambda calculus: in Hydra, "graphs are programs, and programs are graphs". This package is Hydra's build system, promoted into Hydra itself: the manifest-derived module-to-package router, kernel/host reconciliation utilities, and pure module-list helpers, expressed as Hydra modules and generated into every self-hosting dialect. It builds on hydra-kernel. category:       Data@@ -32,6 +32,18 @@       Hydra.Build.Benchresult       Hydra.Build.Comparereport       Hydra.Build.Comparereportlogic+      Hydra.Build.Decode.Assembly+      Hydra.Build.Decode.Benchresult+      Hydra.Build.Decode.Comparereport+      Hydra.Build.Decode.Format+      Hydra.Build.Dsl.Assembly+      Hydra.Build.Dsl.Benchresult+      Hydra.Build.Dsl.Comparereport+      Hydra.Build.Dsl.Format+      Hydra.Build.Encode.Assembly+      Hydra.Build.Encode.Benchresult+      Hydra.Build.Encode.Comparereport+      Hydra.Build.Encode.Format       Hydra.Build.Format       Hydra.Build.Langexpansion       Hydra.Build.Libraries@@ -45,18 +57,6 @@       Hydra.Build.Syncmatrix       Hydra.Build.Versionconsistency       Hydra.Build.Walk-      Hydra.Decode.Build.Assembly-      Hydra.Decode.Build.Benchresult-      Hydra.Decode.Build.Comparereport-      Hydra.Decode.Build.Format-      Hydra.Dsl.Build.Assembly-      Hydra.Dsl.Build.Benchresult-      Hydra.Dsl.Build.Comparereport-      Hydra.Dsl.Build.Format-      Hydra.Encode.Build.Assembly-      Hydra.Encode.Build.Benchresult-      Hydra.Encode.Build.Comparereport-      Hydra.Encode.Build.Format   other-modules:       Paths_hydra_build   hs-source-dirs:@@ -64,6 +64,6 @@   build-depends:       base >=4.19.0 && <4.22     , containers >=0.6.7 && <0.8-    , hydra-kernel ==0.17.7+    , hydra-kernel ==0.18.0     , scientific >=0.3.7 && <0.4   default-language: Haskell2010

@@ -4,7 +4,7 @@  module Hydra.Build.Assembly where -import qualified Hydra.Core as Core+import qualified Hydra.Core.Model as Model import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import Data.Void@@ -22,15 +22,15 @@     assemblyEntryExclude :: [String]}   deriving (Eq, Ord, Read, Show) -_AssemblyEntry = Core.Name "hydra.build.assembly.AssemblyEntry"+_AssemblyEntry = Model.Name "hydra.build.assembly.AssemblyEntry" -_AssemblyEntry_sourceTree = Core.Name "sourceTree"+_AssemblyEntry_sourceTree = Model.Name "sourceTree" -_AssemblyEntry_destTree = Core.Name "destTree"+_AssemblyEntry_destTree = Model.Name "destTree" -_AssemblyEntry_kind = Core.Name "kind"+_AssemblyEntry_kind = Model.Name "kind" -_AssemblyEntry_exclude = Core.Name "exclude"+_AssemblyEntry_exclude = Model.Name "exclude"  -- | How an assembly entry's source tree is realized at its destination. The distinction gates the host-native executor's dispatch (merge-copy vs. wipe-then-copy vs. symlink). data AssemblyEntryKind =@@ -44,15 +44,15 @@   AssemblyEntryKindSymlinkDir   deriving (Eq, Ord, Read, Show) -_AssemblyEntryKind = Core.Name "hydra.build.assembly.AssemblyEntryKind"+_AssemblyEntryKind = Model.Name "hydra.build.assembly.AssemblyEntryKind" -_AssemblyEntryKind_merge = Core.Name "merge"+_AssemblyEntryKind_merge = Model.Name "merge" -_AssemblyEntryKind_wipeThenCopy = Core.Name "wipeThenCopy"+_AssemblyEntryKind_wipeThenCopy = Model.Name "wipeThenCopy" -_AssemblyEntryKind_symlinkTree = Core.Name "symlinkTree"+_AssemblyEntryKind_symlinkTree = Model.Name "symlinkTree" -_AssemblyEntryKind_symlinkDir = Core.Name "symlinkDir"+_AssemblyEntryKind_symlinkDir = Model.Name "symlinkDir"  -- | The complete assembly plan for one distribution package in one target language: the ordered copy/symlink entries to realize and the keep-paths a pruning consumer must protect. Entries are ordered because realization order can matter (e.g. a package that links its own subtree back into an already-assembled dependency's tree). data AssemblyPlan =@@ -63,11 +63,11 @@     assemblyPlanKeepPaths :: [KeepPathEntry]}   deriving (Eq, Ord, Read, Show) -_AssemblyPlan = Core.Name "hydra.build.assembly.AssemblyPlan"+_AssemblyPlan = Model.Name "hydra.build.assembly.AssemblyPlan" -_AssemblyPlan_entries = Core.Name "entries"+_AssemblyPlan_entries = Model.Name "entries" -_AssemblyPlan_keepPaths = Core.Name "keepPaths"+_AssemblyPlan_keepPaths = Model.Name "keepPaths"  -- | One protected path in a keep-paths manifest: a source-set directory paired with a file's path relative to it. Serialized by the native executor as <sourceSetDir>\t<relPath>, bit-compatible with the prune-stale (#357) and digest-check --keep-paths-from consumers. data KeepPathEntry =@@ -78,8 +78,8 @@     keepPathEntryRelPath :: String}   deriving (Eq, Ord, Read, Show) -_KeepPathEntry = Core.Name "hydra.build.assembly.KeepPathEntry"+_KeepPathEntry = Model.Name "hydra.build.assembly.KeepPathEntry" -_KeepPathEntry_sourceSetDir = Core.Name "sourceSetDir"+_KeepPathEntry_sourceSetDir = Model.Name "sourceSetDir" -_KeepPathEntry_relPath = Core.Name "relPath"+_KeepPathEntry_relPath = Model.Name "relPath"

@@ -4,38 +4,40 @@  module Hydra.Build.Assemblyplan where -import qualified Hydra.Ast as Ast-import qualified Hydra.Coders as Coders-import qualified Hydra.Core as Core-import qualified Hydra.Docs as Docs-import qualified Hydra.Error.Checking as Checking-import qualified Hydra.Error.Core as ErrorCore-import qualified Hydra.Error.File as ErrorFile-import qualified Hydra.Error.Packaging as ErrorPackaging-import qualified Hydra.Error.System as ErrorSystem-import qualified Hydra.Errors as Errors-import qualified Hydra.File as File-import qualified Hydra.Graph as Graph-import qualified Hydra.Json.Model as Model-import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists-import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs-import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings-import qualified Hydra.Packaging as Packaging-import qualified Hydra.Parsing as Parsing-import qualified Hydra.Paths as Paths-import qualified Hydra.Query as Query-import qualified Hydra.Regex as Regex-import qualified Hydra.Relational as Relational-import qualified Hydra.System as System-import qualified Hydra.Tabular as Tabular-import qualified Hydra.Testing as Testing-import qualified Hydra.Time as Time-import qualified Hydra.Topology as Topology-import qualified Hydra.Typed as Typed-import qualified Hydra.Typing as Typing-import qualified Hydra.Util as Util-import qualified Hydra.Validation as Validation-import qualified Hydra.Variants as Variants+import qualified Hydra.Core.Ast as Ast+import qualified Hydra.Core.Coders as Coders+import qualified Hydra.Core.Diff as Diff+import qualified Hydra.Core.Docs as Docs+import qualified Hydra.Core.Error.Checking as Checking+import qualified Hydra.Core.Error.File as ErrorFile+import qualified Hydra.Core.Error.Model as ErrorModel+import qualified Hydra.Core.Error.Packaging as ErrorPackaging+import qualified Hydra.Core.Error.System as ErrorSystem+import qualified Hydra.Core.Errors as Errors+import qualified Hydra.Core.File as File+import qualified Hydra.Core.Graph as Graph+import qualified Hydra.Core.Json.Model as JsonModel+import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists+import qualified Hydra.Core.Overlay.Haskell.Lib.Pairs as Pairs+import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings+import qualified Hydra.Core.Markdown as Markdown+import qualified Hydra.Core.Model as Model+import qualified Hydra.Core.Packaging as Packaging+import qualified Hydra.Core.Parsing as Parsing+import qualified Hydra.Core.Paths as Paths+import qualified Hydra.Core.Query as Query+import qualified Hydra.Core.Regex as Regex+import qualified Hydra.Core.Relational as Relational+import qualified Hydra.Core.System as System+import qualified Hydra.Core.Tabular as Tabular+import qualified Hydra.Core.Testing as Testing+import qualified Hydra.Core.Time as Time+import qualified Hydra.Core.Topology as Topology+import qualified Hydra.Core.Typed as Typed+import qualified Hydra.Core.Typing as Typing+import qualified Hydra.Core.Util as Util+import qualified Hydra.Core.Validation as Validation+import qualified Hydra.Core.Variants as Variants import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import Data.Void

@@ -4,7 +4,7 @@  module Hydra.Build.Benchresult where -import qualified Hydra.Core as Core+import qualified Hydra.Core.Model as Model import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import Data.Void@@ -25,17 +25,17 @@     benchMetadataCommitMessage :: String}   deriving (Eq, Ord, Read, Show) -_BenchMetadata = Core.Name "hydra.build.benchresult.BenchMetadata"+_BenchMetadata = Model.Name "hydra.build.benchresult.BenchMetadata" -_BenchMetadata_timestamp = Core.Name "timestamp"+_BenchMetadata_timestamp = Model.Name "timestamp" -_BenchMetadata_language = Core.Name "language"+_BenchMetadata_language = Model.Name "language" -_BenchMetadata_branch = Core.Name "branch"+_BenchMetadata_branch = Model.Name "branch" -_BenchMetadata_commit = Core.Name "commit"+_BenchMetadata_commit = Model.Name "commit" -_BenchMetadata_commitMessage = Core.Name "commitMessage"+_BenchMetadata_commitMessage = Model.Name "commitMessage"  -- | A generator-benchmark result: target, run count, and per-host results data GenBenchResult =@@ -50,15 +50,15 @@     genBenchResultMetadata :: (Maybe BenchMetadata)}   deriving (Eq, Ord, Read, Show) -_GenBenchResult = Core.Name "hydra.build.benchresult.GenBenchResult"+_GenBenchResult = Model.Name "hydra.build.benchresult.GenBenchResult" -_GenBenchResult_target = Core.Name "target"+_GenBenchResult_target = Model.Name "target" -_GenBenchResult_runs = Core.Name "runs"+_GenBenchResult_runs = Model.Name "runs" -_GenBenchResult_hosts = Core.Name "hosts"+_GenBenchResult_hosts = Model.Name "hosts" -_GenBenchResult_metadata = Core.Name "metadata"+_GenBenchResult_metadata = Model.Name "metadata"  -- | One host's generator-benchmark result: setup time and per-package timings data HostResult =@@ -69,11 +69,11 @@     hostResultPackages :: (M.Map String RunStats)}   deriving (Eq, Ord, Read, Show) -_HostResult = Core.Name "hydra.build.benchresult.HostResult"+_HostResult = Model.Name "hydra.build.benchresult.HostResult" -_HostResult_setupMs = Core.Name "setupMs"+_HostResult_setupMs = Model.Name "setupMs" -_HostResult_packages = Core.Name "packages"+_HostResult_packages = Model.Name "packages"  -- | Timing statistics for one (host, package): per-run elapsed times and the median data RunStats =@@ -84,8 +84,8 @@     runStatsMedianMs :: Int}   deriving (Eq, Ord, Read, Show) -_RunStats = Core.Name "hydra.build.benchresult.RunStats"+_RunStats = Model.Name "hydra.build.benchresult.RunStats" -_RunStats_runsMs = Core.Name "runsMs"+_RunStats_runsMs = Model.Name "runsMs" -_RunStats_medianMs = Core.Name "medianMs"+_RunStats_medianMs = Model.Name "medianMs"

@@ -4,7 +4,7 @@  module Hydra.Build.Comparereport where -import qualified Hydra.Core as Core+import qualified Hydra.Core.Model as Model import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import Data.Void@@ -20,13 +20,13 @@     compareReportTotal :: Int}   deriving (Eq, Ord, Read, Show) -_CompareReport = Core.Name "hydra.build.comparereport.CompareReport"+_CompareReport = Model.Name "hydra.build.comparereport.CompareReport" -_CompareReport_rows = Core.Name "rows"+_CompareReport_rows = Model.Name "rows" -_CompareReport_byteEqCount = Core.Name "byteEqCount"+_CompareReport_byteEqCount = Model.Name "byteEqCount" -_CompareReport_total = Core.Name "total"+_CompareReport_total = Model.Name "total"  -- | The result of comparing one module's JSON on the two sides data CompareStatus =@@ -38,13 +38,13 @@   CompareStatusMissing   deriving (Eq, Ord, Read, Show) -_CompareStatus = Core.Name "hydra.build.comparereport.CompareStatus"+_CompareStatus = Model.Name "hydra.build.comparereport.CompareStatus" -_CompareStatus_byteEq = Core.Name "byteEq"+_CompareStatus_byteEq = Model.Name "byteEq" -_CompareStatus_differ = Core.Name "differ"+_CompareStatus_differ = Model.Name "differ" -_CompareStatus_missing = Core.Name "missing"+_CompareStatus_missing = Model.Name "missing"  -- | One module's comparison record data ModuleCompare =@@ -61,14 +61,14 @@     moduleCompareDiffLines :: Int}   deriving (Eq, Ord, Read, Show) -_ModuleCompare = Core.Name "hydra.build.comparereport.ModuleCompare"+_ModuleCompare = Model.Name "hydra.build.comparereport.ModuleCompare" -_ModuleCompare_module = Core.Name "module"+_ModuleCompare_module = Model.Name "module" -_ModuleCompare_status = Core.Name "status"+_ModuleCompare_status = Model.Name "status" -_ModuleCompare_ourSize = Core.Name "ourSize"+_ModuleCompare_ourSize = Model.Name "ourSize" -_ModuleCompare_canonSize = Core.Name "canonSize"+_ModuleCompare_canonSize = Model.Name "canonSize" -_ModuleCompare_diffLines = Core.Name "diffLines"+_ModuleCompare_diffLines = Model.Name "diffLines"

@@ -4,45 +4,47 @@  module Hydra.Build.Comparereportlogic where -import qualified Hydra.Ast as Ast import qualified Hydra.Build.Walk as Walk-import qualified Hydra.Coders as Coders-import qualified Hydra.Core as Core-import qualified Hydra.Docs as Docs-import qualified Hydra.Error.Checking as Checking-import qualified Hydra.Error.Core as ErrorCore-import qualified Hydra.Error.File as ErrorFile-import qualified Hydra.Error.Packaging as ErrorPackaging-import qualified Hydra.Error.System as ErrorSystem-import qualified Hydra.Errors as Errors-import qualified Hydra.File as File-import qualified Hydra.Graph as Graph-import qualified Hydra.Json.Model as Model-import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality-import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists-import qualified Hydra.Overlay.Haskell.Lib.Literals as Literals-import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic-import qualified Hydra.Overlay.Haskell.Lib.Math as Math-import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals-import qualified Hydra.Overlay.Haskell.Lib.Ordering as Ordering-import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs-import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings-import qualified Hydra.Packaging as Packaging-import qualified Hydra.Parsing as Parsing-import qualified Hydra.Paths as Paths-import qualified Hydra.Query as Query-import qualified Hydra.Regex as Regex-import qualified Hydra.Relational as Relational-import qualified Hydra.System as System-import qualified Hydra.Tabular as Tabular-import qualified Hydra.Testing as Testing-import qualified Hydra.Time as Time-import qualified Hydra.Topology as Topology-import qualified Hydra.Typed as Typed-import qualified Hydra.Typing as Typing-import qualified Hydra.Util as Util-import qualified Hydra.Validation as Validation-import qualified Hydra.Variants as Variants+import qualified Hydra.Core.Ast as Ast+import qualified Hydra.Core.Coders as Coders+import qualified Hydra.Core.Diff as Diff+import qualified Hydra.Core.Docs as Docs+import qualified Hydra.Core.Error.Checking as Checking+import qualified Hydra.Core.Error.File as ErrorFile+import qualified Hydra.Core.Error.Model as ErrorModel+import qualified Hydra.Core.Error.Packaging as ErrorPackaging+import qualified Hydra.Core.Error.System as ErrorSystem+import qualified Hydra.Core.Errors as Errors+import qualified Hydra.Core.File as File+import qualified Hydra.Core.Graph as Graph+import qualified Hydra.Core.Json.Model as JsonModel+import qualified Hydra.Core.Overlay.Haskell.Lib.Equality as Equality+import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists+import qualified Hydra.Core.Overlay.Haskell.Lib.Literals as Literals+import qualified Hydra.Core.Overlay.Haskell.Lib.Logic as Logic+import qualified Hydra.Core.Overlay.Haskell.Lib.Math as Math+import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Core.Overlay.Haskell.Lib.Ordering as Ordering+import qualified Hydra.Core.Overlay.Haskell.Lib.Pairs as Pairs+import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings+import qualified Hydra.Core.Markdown as Markdown+import qualified Hydra.Core.Model as Model+import qualified Hydra.Core.Packaging as Packaging+import qualified Hydra.Core.Parsing as Parsing+import qualified Hydra.Core.Paths as Paths+import qualified Hydra.Core.Query as Query+import qualified Hydra.Core.Regex as Regex+import qualified Hydra.Core.Relational as Relational+import qualified Hydra.Core.System as System+import qualified Hydra.Core.Tabular as Tabular+import qualified Hydra.Core.Testing as Testing+import qualified Hydra.Core.Time as Time+import qualified Hydra.Core.Topology as Topology+import qualified Hydra.Core.Typed as Typed+import qualified Hydra.Core.Typing as Typing+import qualified Hydra.Core.Util as Util+import qualified Hydra.Core.Validation as Validation+import qualified Hydra.Core.Variants as Variants import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import Data.Void

@@ -0,0 +1,102 @@+-- Note: this is an automatically generated file. Do not edit.++-- | Term decoders for hydra.build.assembly++module Hydra.Build.Decode.Assembly where++import qualified Hydra.Build.Assembly as Assembly+import qualified Hydra.Core.Errors as Errors+import qualified Hydra.Core.Extract.Model as ExtractModel+import qualified Hydra.Core.Graph as Graph+import qualified Hydra.Core.Lexical as Lexical+import qualified Hydra.Core.Overlay.Haskell.Lib.Eithers as Eithers+import qualified Hydra.Core.Overlay.Haskell.Lib.Maps as Maps+import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings+import qualified Hydra.Core.Model as Model+import qualified Hydra.Core.Rewriting as Rewriting+import qualified Hydra.Core.Util as Util+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)+import qualified Data.Scientific as Sci+import Data.Void++-- | Decoder for hydra.build.assembly.AssemblyEntry+assemblyEntry :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Assembly.AssemblyEntry+assemblyEntry cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermRecord v0 ->+        let fieldMap = ExtractModel.toFieldMap v0+        in (Eithers.bind (ExtractModel.requireField "sourceTree" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_sourceTree -> Eithers.bind (ExtractModel.requireField "destTree" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_destTree -> Eithers.bind (ExtractModel.requireField "kind" assemblyEntryKind fieldMap cx) (\field_kind -> Eithers.bind (ExtractModel.requireField "exclude" (ExtractModel.decodeList (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2))) fieldMap cx) (\field_exclude -> Right (Assembly.AssemblyEntry {+          Assembly.assemblyEntrySourceTree = field_sourceTree,+          Assembly.assemblyEntryDestTree = field_destTree,+          Assembly.assemblyEntryKind = field_kind,+          Assembly.assemblyEntryExclude = field_exclude}))))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.build.assembly.AssemblyEntry")) (ExtractModel.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.assembly.AssemblyEntryKind+assemblyEntryKind :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Assembly.AssemblyEntryKind+assemblyEntryKind cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermInject v0 ->+        let field = Model.injectionField v0+            fname = Model.fieldName field+            fterm = Model.fieldTerm field+            variantMap =+                    Maps.fromList [+                      (Model.Name "merge", (\input -> Eithers.map (\t -> Assembly.AssemblyEntryKindMerge) (ExtractModel.decodeUnit cx input))),+                      (+                        Model.Name "wipeThenCopy",+                        (\input -> Eithers.map (\t -> Assembly.AssemblyEntryKindWipeThenCopy) (ExtractModel.decodeUnit cx input))),+                      (+                        Model.Name "symlinkTree",+                        (\input -> Eithers.map (\t -> Assembly.AssemblyEntryKindSymlinkTree) (ExtractModel.decodeUnit cx input))),+                      (+                        Model.Name "symlinkDir",+                        (\input -> Eithers.map (\t -> Assembly.AssemblyEntryKindSymlinkDir) (ExtractModel.decodeUnit cx input)))]+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+          "no such field ",+          (Model.unName fname),+          " in union"]))) (\f -> f fterm))+      _ -> Left (Errors.DecodingError "expected union")) (ExtractModel.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.assembly.AssemblyPlan+assemblyPlan :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Assembly.AssemblyPlan+assemblyPlan cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermRecord v0 ->+        let fieldMap = ExtractModel.toFieldMap v0+        in (Eithers.bind (ExtractModel.requireField "entries" (ExtractModel.decodeList assemblyEntry) fieldMap cx) (\field_entries -> Eithers.bind (ExtractModel.requireField "keepPaths" (ExtractModel.decodeList keepPathEntry) fieldMap cx) (\field_keepPaths -> Right (Assembly.AssemblyPlan {+          Assembly.assemblyPlanEntries = field_entries,+          Assembly.assemblyPlanKeepPaths = field_keepPaths}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.build.assembly.AssemblyPlan")) (ExtractModel.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.assembly.KeepPathEntry+keepPathEntry :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Assembly.KeepPathEntry+keepPathEntry cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermRecord v0 ->+        let fieldMap = ExtractModel.toFieldMap v0+        in (Eithers.bind (ExtractModel.requireField "sourceSetDir" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_sourceSetDir -> Eithers.bind (ExtractModel.requireField "relPath" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_relPath -> Right (Assembly.KeepPathEntry {+          Assembly.keepPathEntrySourceSetDir = field_sourceSetDir,+          Assembly.keepPathEntryRelPath = field_relPath}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.build.assembly.KeepPathEntry")) (ExtractModel.stripWithDecodingError cx raw)

@@ -0,0 +1,123 @@+-- Note: this is an automatically generated file. Do not edit.++-- | Term decoders for hydra.build.benchresult++module Hydra.Build.Decode.Benchresult where++import qualified Hydra.Build.Benchresult as Benchresult+import qualified Hydra.Core.Errors as Errors+import qualified Hydra.Core.Extract.Model as ExtractModel+import qualified Hydra.Core.Graph as Graph+import qualified Hydra.Core.Lexical as Lexical+import qualified Hydra.Core.Overlay.Haskell.Lib.Eithers as Eithers+import qualified Hydra.Core.Model as Model+import qualified Hydra.Core.Rewriting as Rewriting+import qualified Hydra.Core.Util as Util+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)+import qualified Data.Scientific as Sci+import Data.Void++-- | Decoder for hydra.build.benchresult.BenchMetadata+benchMetadata :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Benchresult.BenchMetadata+benchMetadata cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermRecord v0 ->+        let fieldMap = ExtractModel.toFieldMap v0+        in (Eithers.bind (ExtractModel.requireField "timestamp" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_timestamp -> Eithers.bind (ExtractModel.requireField "language" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_language -> Eithers.bind (ExtractModel.requireField "branch" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_branch -> Eithers.bind (ExtractModel.requireField "commit" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_commit -> Eithers.bind (ExtractModel.requireField "commitMessage" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_commitMessage -> Right (Benchresult.BenchMetadata {+          Benchresult.benchMetadataTimestamp = field_timestamp,+          Benchresult.benchMetadataLanguage = field_language,+          Benchresult.benchMetadataBranch = field_branch,+          Benchresult.benchMetadataCommit = field_commit,+          Benchresult.benchMetadataCommitMessage = field_commitMessage})))))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.build.benchresult.BenchMetadata")) (ExtractModel.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.benchresult.GenBenchResult+genBenchResult :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Benchresult.GenBenchResult+genBenchResult cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermRecord v0 ->+        let fieldMap = ExtractModel.toFieldMap v0+        in (Eithers.bind (ExtractModel.requireField "target" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_target -> Eithers.bind (ExtractModel.requireField "runs" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralInteger v2 -> case v2 of+              Model.IntegerValueInt32 v3 -> Right v3+              _ -> Left (Errors.DecodingError "expected int32 value")+            _ -> Left (Errors.DecodingError "expected int32 literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_runs -> Eithers.bind (ExtractModel.requireField "hosts" (ExtractModel.decodeMap (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) hostResult) fieldMap cx) (\field_hosts -> Eithers.bind (ExtractModel.requireField "metadata" (ExtractModel.decodeMaybe benchMetadata) fieldMap cx) (\field_metadata -> Right (Benchresult.GenBenchResult {+          Benchresult.genBenchResultTarget = field_target,+          Benchresult.genBenchResultRuns = field_runs,+          Benchresult.genBenchResultHosts = field_hosts,+          Benchresult.genBenchResultMetadata = field_metadata}))))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.build.benchresult.GenBenchResult")) (ExtractModel.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.benchresult.HostResult+hostResult :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Benchresult.HostResult+hostResult cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermRecord v0 ->+        let fieldMap = ExtractModel.toFieldMap v0+        in (Eithers.bind (ExtractModel.requireField "setupMs" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralInteger v2 -> case v2 of+              Model.IntegerValueInt32 v3 -> Right v3+              _ -> Left (Errors.DecodingError "expected int32 value")+            _ -> Left (Errors.DecodingError "expected int32 literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_setupMs -> Eithers.bind (ExtractModel.requireField "packages" (ExtractModel.decodeMap (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) runStats) fieldMap cx) (\field_packages -> Right (Benchresult.HostResult {+          Benchresult.hostResultSetupMs = field_setupMs,+          Benchresult.hostResultPackages = field_packages}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.build.benchresult.HostResult")) (ExtractModel.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.benchresult.RunStats+runStats :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Benchresult.RunStats+runStats cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermRecord v0 ->+        let fieldMap = ExtractModel.toFieldMap v0+        in (Eithers.bind (ExtractModel.requireField "runsMs" (ExtractModel.decodeList (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralInteger v2 -> case v2 of+              Model.IntegerValueInt32 v3 -> Right v3+              _ -> Left (Errors.DecodingError "expected int32 value")+            _ -> Left (Errors.DecodingError "expected int32 literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2))) fieldMap cx) (\field_runsMs -> Eithers.bind (ExtractModel.requireField "medianMs" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralInteger v2 -> case v2 of+              Model.IntegerValueInt32 v3 -> Right v3+              _ -> Left (Errors.DecodingError "expected int32 value")+            _ -> Left (Errors.DecodingError "expected int32 literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_medianMs -> Right (Benchresult.RunStats {+          Benchresult.runStatsRunsMs = field_runsMs,+          Benchresult.runStatsMedianMs = field_medianMs}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.build.benchresult.RunStats")) (ExtractModel.stripWithDecodingError cx raw)

@@ -0,0 +1,106 @@+-- Note: this is an automatically generated file. Do not edit.++-- | Term decoders for hydra.build.comparereport++module Hydra.Build.Decode.Comparereport where++import qualified Hydra.Build.Comparereport as Comparereport+import qualified Hydra.Core.Errors as Errors+import qualified Hydra.Core.Extract.Model as ExtractModel+import qualified Hydra.Core.Graph as Graph+import qualified Hydra.Core.Lexical as Lexical+import qualified Hydra.Core.Overlay.Haskell.Lib.Eithers as Eithers+import qualified Hydra.Core.Overlay.Haskell.Lib.Maps as Maps+import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings+import qualified Hydra.Core.Model as Model+import qualified Hydra.Core.Rewriting as Rewriting+import qualified Hydra.Core.Util as Util+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)+import qualified Data.Scientific as Sci+import Data.Void++-- | Decoder for hydra.build.comparereport.CompareReport+compareReport :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Comparereport.CompareReport+compareReport cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermRecord v0 ->+        let fieldMap = ExtractModel.toFieldMap v0+        in (Eithers.bind (ExtractModel.requireField "rows" (ExtractModel.decodeList moduleCompare) fieldMap cx) (\field_rows -> Eithers.bind (ExtractModel.requireField "byteEqCount" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralInteger v2 -> case v2 of+              Model.IntegerValueInt32 v3 -> Right v3+              _ -> Left (Errors.DecodingError "expected int32 value")+            _ -> Left (Errors.DecodingError "expected int32 literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_byteEqCount -> Eithers.bind (ExtractModel.requireField "total" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralInteger v2 -> case v2 of+              Model.IntegerValueInt32 v3 -> Right v3+              _ -> Left (Errors.DecodingError "expected int32 value")+            _ -> Left (Errors.DecodingError "expected int32 literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_total -> Right (Comparereport.CompareReport {+          Comparereport.compareReportRows = field_rows,+          Comparereport.compareReportByteEqCount = field_byteEqCount,+          Comparereport.compareReportTotal = field_total})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.build.comparereport.CompareReport")) (ExtractModel.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.comparereport.CompareStatus+compareStatus :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Comparereport.CompareStatus+compareStatus cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermInject v0 ->+        let field = Model.injectionField v0+            fname = Model.fieldName field+            fterm = Model.fieldTerm field+            variantMap =+                    Maps.fromList [+                      (+                        Model.Name "byteEq",+                        (\input -> Eithers.map (\t -> Comparereport.CompareStatusByteEq) (ExtractModel.decodeUnit cx input))),+                      (+                        Model.Name "differ",+                        (\input -> Eithers.map (\t -> Comparereport.CompareStatusDiffer) (ExtractModel.decodeUnit cx input))),+                      (+                        Model.Name "missing",+                        (\input -> Eithers.map (\t -> Comparereport.CompareStatusMissing) (ExtractModel.decodeUnit cx input)))]+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+          "no such field ",+          (Model.unName fname),+          " in union"]))) (\f -> f fterm))+      _ -> Left (Errors.DecodingError "expected union")) (ExtractModel.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.comparereport.ModuleCompare+moduleCompare :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Comparereport.ModuleCompare+moduleCompare cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermRecord v0 ->+        let fieldMap = ExtractModel.toFieldMap v0+        in (Eithers.bind (ExtractModel.requireField "module" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_module -> Eithers.bind (ExtractModel.requireField "status" compareStatus fieldMap cx) (\field_status -> Eithers.bind (ExtractModel.requireField "ourSize" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralInteger v2 -> case v2 of+              Model.IntegerValueInt32 v3 -> Right v3+              _ -> Left (Errors.DecodingError "expected int32 value")+            _ -> Left (Errors.DecodingError "expected int32 literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_ourSize -> Eithers.bind (ExtractModel.requireField "canonSize" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralInteger v2 -> case v2 of+              Model.IntegerValueInt32 v3 -> Right v3+              _ -> Left (Errors.DecodingError "expected int32 value")+            _ -> Left (Errors.DecodingError "expected int32 literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_canonSize -> Eithers.bind (ExtractModel.requireField "diffLines" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralInteger v2 -> case v2 of+              Model.IntegerValueInt32 v3 -> Right v3+              _ -> Left (Errors.DecodingError "expected int32 value")+            _ -> Left (Errors.DecodingError "expected int32 literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_diffLines -> Right (Comparereport.ModuleCompare {+          Comparereport.moduleCompareModule = field_module,+          Comparereport.moduleCompareStatus = field_status,+          Comparereport.moduleCompareOurSize = field_ourSize,+          Comparereport.moduleCompareCanonSize = field_canonSize,+          Comparereport.moduleCompareDiffLines = field_diffLines})))))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.build.comparereport.ModuleCompare")) (ExtractModel.stripWithDecodingError cx raw)

@@ -0,0 +1,444 @@+-- Note: this is an automatically generated file. Do not edit.++-- | Term decoders for hydra.build.format++module Hydra.Build.Decode.Format where++import qualified Hydra.Build.Format as Format+import qualified Hydra.Core.Decode.Packaging as Packaging+import qualified Hydra.Core.Errors as Errors+import qualified Hydra.Core.Extract.Model as ExtractModel+import qualified Hydra.Core.Graph as Graph+import qualified Hydra.Core.Lexical as Lexical+import qualified Hydra.Core.Overlay.Haskell.Lib.Eithers as Eithers+import qualified Hydra.Core.Overlay.Haskell.Lib.Maps as Maps+import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Core.Overlay.Haskell.Lib.Strings as Strings+import qualified Hydra.Core.Model as Model+import qualified Hydra.Core.Rewriting as Rewriting+import qualified Hydra.Core.Util as Util+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)+import qualified Data.Scientific as Sci+import Data.Void++-- | Decoder for hydra.build.format.DefinitionNameConventionProfile+definitionNameConventionProfile :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.DefinitionNameConventionProfile+definitionNameConventionProfile cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermRecord v0 ->+        let fieldMap = ExtractModel.toFieldMap v0+        in (Eithers.bind (ExtractModel.requireField "severity" severity fieldMap cx) (\field_severity -> Eithers.bind (ExtractModel.requireField "allowUnderscores" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralBoolean v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected boolean literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_allowUnderscores -> Right (Format.DefinitionNameConventionProfile {+          Format.definitionNameConventionProfileSeverity = field_severity,+          Format.definitionNameConventionProfileAllowUnderscores = field_allowUnderscores}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.DefinitionNameConventionProfile")) (ExtractModel.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.DefinitionValidationProfile+definitionValidationProfile :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.DefinitionValidationProfile+definitionValidationProfile cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermRecord v0 ->+        let fieldMap = ExtractModel.toFieldMap v0+        in (Eithers.bind (ExtractModel.requireField "hasDescription" (ExtractModel.decodeMaybe documentationProfile) fieldMap cx) (\field_hasDescription -> Eithers.bind (ExtractModel.requireField "ordering" (ExtractModel.decodeMaybe severity) fieldMap cx) (\field_ordering -> Eithers.bind (ExtractModel.requireField "nameConvention" (ExtractModel.decodeMaybe definitionNameConventionProfile) fieldMap cx) (\field_nameConvention -> Eithers.bind (ExtractModel.requireField "notInModuleName" (ExtractModel.decodeMaybe severity) fieldMap cx) (\field_notInModuleName -> Eithers.bind (ExtractModel.requireField "duplicateName" (ExtractModel.decodeMaybe severity) fieldMap cx) (\field_duplicateName -> Right (Format.DefinitionValidationProfile {+          Format.definitionValidationProfileHasDescription = field_hasDescription,+          Format.definitionValidationProfileOrdering = field_ordering,+          Format.definitionValidationProfileNameConvention = field_nameConvention,+          Format.definitionValidationProfileNotInModuleName = field_notInModuleName,+          Format.definitionValidationProfileDuplicateName = field_duplicateName})))))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.DefinitionValidationProfile")) (ExtractModel.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.DigestEntry+digestEntry :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.DigestEntry+digestEntry cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermRecord v0 ->+        let fieldMap = ExtractModel.toFieldMap v0+        in (Eithers.bind (ExtractModel.requireField "kind" digestKind fieldMap cx) (\field_kind -> Eithers.bind (ExtractModel.requireField "hash" sha256Hash fieldMap cx) (\field_hash -> Right (Format.DigestEntry {+          Format.digestEntryKind = field_kind,+          Format.digestEntryHash = field_hash}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.DigestEntry")) (ExtractModel.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.DigestKind+digestKind :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.DigestKind+digestKind cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermInject v0 ->+        let field = Model.injectionField v0+            fname = Model.fieldName field+            fterm = Model.fieldTerm field+            variantMap =+                    Maps.fromList [+                      (Model.Name "dslSource", (\input -> Eithers.map (\t -> Format.DigestKindDslSource) (ExtractModel.decodeUnit cx input))),+                      (Model.Name "jsonFile", (\input -> Eithers.map (\t -> Format.DigestKindJsonFile) (ExtractModel.decodeUnit cx input))),+                      (Model.Name "targetFile", (\input -> Eithers.map (\t -> Format.DigestKindTargetFile) (ExtractModel.decodeUnit cx input))),+                      (+                        Model.Name "runtimeFile",+                        (\input -> Eithers.map (\t -> Format.DigestKindRuntimeFile) (ExtractModel.decodeUnit cx input))),+                      (Model.Name "other", (\input -> Eithers.map (\t -> Format.DigestKindOther) (ExtractModel.decodeUnit cx input)))]+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+          "no such field ",+          (Model.unName fname),+          " in union"]))) (\f -> f fterm))+      _ -> Left (Errors.DecodingError "expected union")) (ExtractModel.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.DocumentationProfile+documentationProfile :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.DocumentationProfile+documentationProfile cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermRecord v0 ->+        let fieldMap = ExtractModel.toFieldMap v0+        in (Eithers.bind (ExtractModel.requireField "severity" severity fieldMap cx) (\field_severity -> Eithers.bind (ExtractModel.requireField "exemptDeprecated" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralBoolean v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected boolean literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_exemptDeprecated -> Right (Format.DocumentationProfile {+          Format.documentationProfileSeverity = field_severity,+          Format.documentationProfileExemptDeprecated = field_exemptDeprecated}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.DocumentationProfile")) (ExtractModel.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.Generation+generation :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.Generation+generation cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermRecord v0 ->+        let fieldMap = ExtractModel.toFieldMap v0+        in (Eithers.bind (ExtractModel.requireField "generatorId" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_generatorId -> Eithers.bind (ExtractModel.requireField "mode" generationMode fieldMap cx) (\field_mode -> Eithers.bind (ExtractModel.requireField "host" languageName fieldMap cx) (\field_host -> Eithers.bind (ExtractModel.requireField "hydraVersion" (ExtractModel.decodeMaybe Packaging.version) fieldMap cx) (\field_hydraVersion -> Eithers.bind (ExtractModel.requireField "revision" (ExtractModel.decodeMaybe (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2))) fieldMap cx) (\field_revision -> Eithers.bind (ExtractModel.requireField "timestamp" (ExtractModel.decodeMaybe (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2))) fieldMap cx) (\field_timestamp -> Right (Format.Generation {+          Format.generationGeneratorId = field_generatorId,+          Format.generationMode = field_mode,+          Format.generationHost = field_host,+          Format.generationHydraVersion = field_hydraVersion,+          Format.generationRevision = field_revision,+          Format.generationTimestamp = field_timestamp}))))))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.Generation")) (ExtractModel.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.GenerationMode+generationMode :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.GenerationMode+generationMode cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermInject v0 ->+        let field = Model.injectionField v0+            fname = Model.fieldName field+            fterm = Model.fieldTerm field+            variantMap =+                    Maps.fromList [+                      (+                        Model.Name "published",+                        (\input -> Eithers.map (\t -> Format.GenerationModePublished) (ExtractModel.decodeUnit cx input))),+                      (Model.Name "shim", (\input -> Eithers.map (\t -> Format.GenerationModeShim) (ExtractModel.decodeUnit cx input)))]+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+          "no such field ",+          (Model.unName fname),+          " in union"]))) (\f -> f fterm))+      _ -> Left (Errors.DecodingError "expected union")) (ExtractModel.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.HostOverride+hostOverride :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.HostOverride+hostOverride cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermInject v0 ->+        let field = Model.injectionField v0+            fname = Model.fieldName field+            fterm = Model.fieldTerm field+            variantMap =+                    Maps.fromList [+                      (Model.Name "local", (\input -> Eithers.map (\t -> Format.HostOverrideLocal) (ExtractModel.decodeUnit cx input))),+                      (Model.Name "version", (\input -> Eithers.map (\t -> Format.HostOverrideVersion t) (Packaging.version cx input)))]+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+          "no such field ",+          (Model.unName fname),+          " in union"]))) (\f -> f fterm))+      _ -> Left (Errors.DecodingError "expected union")) (ExtractModel.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.InputDigest+inputDigest :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.InputDigest+inputDigest cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermRecord v0 ->+        let fieldMap = ExtractModel.toFieldMap v0+        in (Eithers.bind (ExtractModel.requireField "digestFormatVersion" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralInteger v2 -> case v2 of+              Model.IntegerValueInt32 v3 -> Right v3+              _ -> Left (Errors.DecodingError "expected int32 value")+            _ -> Left (Errors.DecodingError "expected int32 literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_digestFormatVersion -> Eithers.bind (ExtractModel.requireField "moduleFormatVersion" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralInteger v2 -> case v2 of+              Model.IntegerValueInt32 v3 -> Right v3+              _ -> Left (Errors.DecodingError "expected int32 value")+            _ -> Left (Errors.DecodingError "expected int32 literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_moduleFormatVersion -> Eithers.bind (ExtractModel.requireField "selfHash" (ExtractModel.decodeMaybe sha256Hash) fieldMap cx) (\field_selfHash -> Eithers.bind (ExtractModel.requireField "dependencyHashes" (ExtractModel.decodeMap Packaging.packageName sha256Hash) fieldMap cx) (\field_dependencyHashes -> Eithers.bind (ExtractModel.requireField "moduleHashes" (ExtractModel.decodeMap Packaging.moduleName sha256Hash) fieldMap cx) (\field_moduleHashes -> Right (Format.InputDigest {+          Format.inputDigestDigestFormatVersion = field_digestFormatVersion,+          Format.inputDigestModuleFormatVersion = field_moduleFormatVersion,+          Format.inputDigestSelfHash = field_selfHash,+          Format.inputDigestDependencyHashes = field_dependencyHashes,+          Format.inputDigestModuleHashes = field_moduleHashes})))))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.InputDigest")) (ExtractModel.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.LanguageName+languageName :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.LanguageName+languageName cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermWrap v0 -> Eithers.map (\b -> Format.LanguageName b) ((\raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+        Model.TermLiteral v1 -> case v1 of+          Model.LiteralString v2 -> Right v2+          _ -> Left (Errors.DecodingError "expected string literal")+        _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx raw2)) (Model.wrappedTermBody v0))+      _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractModel.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.LanguageProfile+languageProfile :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.LanguageProfile+languageProfile cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermRecord v0 ->+        let fieldMap = ExtractModel.toFieldMap v0+        in (Eithers.bind (ExtractModel.requireField "name" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_name -> Eithers.bind (ExtractModel.requireField "coderPackage" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_coderPackage -> Eithers.bind (ExtractModel.requireField "family" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_family -> Right (Format.LanguageProfile {+          Format.languageProfileName = field_name,+          Format.languageProfileCoderPackage = field_coderPackage,+          Format.languageProfileFamily = field_family})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.LanguageProfile")) (ExtractModel.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.ModuleValidationProfile+moduleValidationProfile :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.ModuleValidationProfile+moduleValidationProfile cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermRecord v0 ->+        let fieldMap = ExtractModel.toFieldMap v0+        in (Eithers.bind (ExtractModel.requireField "definitions" (ExtractModel.decodeMaybe definitionValidationProfile) fieldMap cx) (\field_definitions -> Eithers.bind (ExtractModel.requireField "nameConvention" (ExtractModel.decodeMaybe severity) fieldMap cx) (\field_nameConvention -> Eithers.bind (ExtractModel.requireField "conflictingVariantName" (ExtractModel.decodeMaybe severity) fieldMap cx) (\field_conflictingVariantName -> Right (Format.ModuleValidationProfile {+          Format.moduleValidationProfileDefinitions = field_definitions,+          Format.moduleValidationProfileNameConvention = field_nameConvention,+          Format.moduleValidationProfileConflictingVariantName = field_conflictingVariantName})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.ModuleValidationProfile")) (ExtractModel.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.OutputDigest+outputDigest :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.OutputDigest+outputDigest cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermRecord v0 ->+        let fieldMap = ExtractModel.toFieldMap v0+        in (Eithers.bind (ExtractModel.requireField "digestFormatVersion" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralInteger v2 -> case v2 of+              Model.IntegerValueInt32 v3 -> Right v3+              _ -> Left (Errors.DecodingError "expected int32 value")+            _ -> Left (Errors.DecodingError "expected int32 literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_digestFormatVersion -> Eithers.bind (ExtractModel.requireField "moduleFormatVersion" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralInteger v2 -> case v2 of+              Model.IntegerValueInt32 v3 -> Right v3+              _ -> Left (Errors.DecodingError "expected int32 value")+            _ -> Left (Errors.DecodingError "expected int32 literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_moduleFormatVersion -> Eithers.bind (ExtractModel.requireField "generator" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_generator -> Eithers.bind (ExtractModel.requireField "generation" generation fieldMap cx) (\field_generation -> Eithers.bind (ExtractModel.requireField "selfHash" (ExtractModel.decodeMaybe sha256Hash) fieldMap cx) (\field_selfHash -> Eithers.bind (ExtractModel.requireField "dependencyHashes" (ExtractModel.decodeMap Packaging.packageName sha256Hash) fieldMap cx) (\field_dependencyHashes -> Eithers.bind (ExtractModel.requireField "inputs" (ExtractModel.decodeMap (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) digestEntry) fieldMap cx) (\field_inputs -> Eithers.bind (ExtractModel.requireField "outputs" (ExtractModel.decodeMap (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) digestEntry) fieldMap cx) (\field_outputs -> Right (Format.OutputDigest {+          Format.outputDigestDigestFormatVersion = field_digestFormatVersion,+          Format.outputDigestModuleFormatVersion = field_moduleFormatVersion,+          Format.outputDigestGenerator = field_generator,+          Format.outputDigestGeneration = field_generation,+          Format.outputDigestSelfHash = field_selfHash,+          Format.outputDigestDependencyHashes = field_dependencyHashes,+          Format.outputDigestInputs = field_inputs,+          Format.outputDigestOutputs = field_outputs}))))))))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.OutputDigest")) (ExtractModel.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.PackageDescriptor+packageDescriptor :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.PackageDescriptor+packageDescriptor cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermRecord v0 ->+        let fieldMap = ExtractModel.toFieldMap v0+        in (Eithers.bind (ExtractModel.requireField "packageFormatVersion" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralInteger v2 -> case v2 of+              Model.IntegerValueInt32 v3 -> Right v3+              _ -> Left (Errors.DecodingError "expected int32 value")+            _ -> Left (Errors.DecodingError "expected int32 literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_packageFormatVersion -> Eithers.bind (ExtractModel.requireField "name" Packaging.packageName fieldMap cx) (\field_name -> Eithers.bind (ExtractModel.requireField "description" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_description -> Eithers.bind (ExtractModel.requireField "sourceLanguage" languageName fieldMap cx) (\field_sourceLanguage -> Eithers.bind (ExtractModel.requireField "targetLanguages" (ExtractModel.decodeMaybe (ExtractModel.decodeList languageName)) fieldMap cx) (\field_targetLanguages -> Eithers.bind (ExtractModel.requireField "dependencies" (ExtractModel.decodeList Packaging.packageName) fieldMap cx) (\field_dependencies -> Eithers.bind (ExtractModel.requireField "validation" (ExtractModel.decodeMaybe packageValidationConfiguration) fieldMap cx) (\field_validation -> Right (Format.PackageDescriptor {+          Format.packageDescriptorPackageFormatVersion = field_packageFormatVersion,+          Format.packageDescriptorName = field_name,+          Format.packageDescriptorDescription = field_description,+          Format.packageDescriptorSourceLanguage = field_sourceLanguage,+          Format.packageDescriptorTargetLanguages = field_targetLanguages,+          Format.packageDescriptorDependencies = field_dependencies,+          Format.packageDescriptorValidation = field_validation})))))))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.PackageDescriptor")) (ExtractModel.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.PackageManifest+packageManifest :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.PackageManifest+packageManifest cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermRecord v0 ->+        let fieldMap = ExtractModel.toFieldMap v0+        in (Eithers.bind (ExtractModel.requireField "manifestFormatVersion" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralInteger v2 -> case v2 of+              Model.IntegerValueInt32 v3 -> Right v3+              _ -> Left (Errors.DecodingError "expected int32 value")+            _ -> Left (Errors.DecodingError "expected int32 literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_manifestFormatVersion -> Eithers.bind (ExtractModel.requireField "moduleFormatVersion" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralInteger v2 -> case v2 of+              Model.IntegerValueInt32 v3 -> Right v3+              _ -> Left (Errors.DecodingError "expected int32 value")+            _ -> Left (Errors.DecodingError "expected int32 literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_moduleFormatVersion -> Eithers.bind (ExtractModel.requireField "package" Packaging.packageName fieldMap cx) (\field_package -> Eithers.bind (ExtractModel.requireField "mainModules" (ExtractModel.decodeList Packaging.moduleName) fieldMap cx) (\field_mainModules -> Eithers.bind (ExtractModel.requireField "testModules" (ExtractModel.decodeList Packaging.moduleName) fieldMap cx) (\field_testModules -> Eithers.bind (ExtractModel.requireField "mainDslModules" (ExtractModel.decodeList Packaging.moduleName) fieldMap cx) (\field_mainDslModules -> Eithers.bind (ExtractModel.requireField "mainEncodingModules" (ExtractModel.decodeList Packaging.moduleName) fieldMap cx) (\field_mainEncodingModules -> Right (Format.PackageManifest {+          Format.packageManifestManifestFormatVersion = field_manifestFormatVersion,+          Format.packageManifestModuleFormatVersion = field_moduleFormatVersion,+          Format.packageManifestPackage = field_package,+          Format.packageManifestMainModules = field_mainModules,+          Format.packageManifestTestModules = field_testModules,+          Format.packageManifestMainDslModules = field_mainDslModules,+          Format.packageManifestMainEncodingModules = field_mainEncodingModules})))))))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.PackageManifest")) (ExtractModel.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.PackageValidationConfiguration+packageValidationConfiguration :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.PackageValidationConfiguration+packageValidationConfiguration cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermRecord v0 ->+        let fieldMap = ExtractModel.toFieldMap v0+        in (Eithers.bind (ExtractModel.requireField "package" (ExtractModel.decodeMaybe packageValidationProfile) fieldMap cx) (\field_package -> Eithers.bind (ExtractModel.requireField "module" (ExtractModel.decodeMaybe moduleValidationProfile) fieldMap cx) (\field_module -> Eithers.bind (ExtractModel.requireField "type" (ExtractModel.decodeMaybe typeValidationProfile) fieldMap cx) (\field_type -> Eithers.bind (ExtractModel.requireField "term" (ExtractModel.decodeMaybe termValidationProfile) fieldMap cx) (\field_term -> Right (Format.PackageValidationConfiguration {+          Format.packageValidationConfigurationPackage = field_package,+          Format.packageValidationConfigurationModule = field_module,+          Format.packageValidationConfigurationType = field_type,+          Format.packageValidationConfigurationTerm = field_term}))))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.PackageValidationConfiguration")) (ExtractModel.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.PackageValidationProfile+packageValidationProfile :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.PackageValidationProfile+packageValidationProfile cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermRecord v0 ->+        let fieldMap = ExtractModel.toFieldMap v0+        in (Eithers.bind (ExtractModel.requireField "conflictingModuleName" (ExtractModel.decodeMaybe severity) fieldMap cx) (\field_conflictingModuleName -> Eithers.bind (ExtractModel.requireField "duplicateModuleName" (ExtractModel.decodeMaybe severity) fieldMap cx) (\field_duplicateModuleName -> Eithers.bind (ExtractModel.requireField "nameConvention" (ExtractModel.decodeMaybe severity) fieldMap cx) (\field_nameConvention -> Right (Format.PackageValidationProfile {+          Format.packageValidationProfileConflictingModuleName = field_conflictingModuleName,+          Format.packageValidationProfileDuplicateModuleName = field_duplicateModuleName,+          Format.packageValidationProfileNameConvention = field_nameConvention})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.PackageValidationProfile")) (ExtractModel.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.RepositoryDescriptor+repositoryDescriptor :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.RepositoryDescriptor+repositoryDescriptor cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermRecord v0 ->+        let fieldMap = ExtractModel.toFieldMap v0+        in (Eithers.bind (ExtractModel.requireField "currentVersion" Packaging.version fieldMap cx) (\field_currentVersion -> Eithers.bind (ExtractModel.requireField "hostVersion" Packaging.version fieldMap cx) (\field_hostVersion -> Eithers.bind (ExtractModel.requireField "hostOverrides" (ExtractModel.decodeMap languageName hostOverride) fieldMap cx) (\field_hostOverrides -> Eithers.bind (ExtractModel.requireField "group" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_group -> Eithers.bind (ExtractModel.requireField "author" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_author -> Eithers.bind (ExtractModel.requireField "url" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_url -> Eithers.bind (ExtractModel.requireField "license" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Model.TermLiteral v1 -> case v1 of+            Model.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_license -> Eithers.bind (ExtractModel.requireField "packages" (ExtractModel.decodeList Packaging.packageName) fieldMap cx) (\field_packages -> Right (Format.RepositoryDescriptor {+          Format.repositoryDescriptorCurrentVersion = field_currentVersion,+          Format.repositoryDescriptorHostVersion = field_hostVersion,+          Format.repositoryDescriptorHostOverrides = field_hostOverrides,+          Format.repositoryDescriptorGroup = field_group,+          Format.repositoryDescriptorAuthor = field_author,+          Format.repositoryDescriptorUrl = field_url,+          Format.repositoryDescriptorLicense = field_license,+          Format.repositoryDescriptorPackages = field_packages}))))))))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.RepositoryDescriptor")) (ExtractModel.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.Severity+severity :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.Severity+severity cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermInject v0 ->+        let field = Model.injectionField v0+            fname = Model.fieldName field+            fterm = Model.fieldTerm field+            variantMap =+                    Maps.fromList [+                      (Model.Name "error", (\input -> Eithers.map (\t -> Format.SeverityError) (ExtractModel.decodeUnit cx input))),+                      (Model.Name "warning", (\input -> Eithers.map (\t -> Format.SeverityWarning) (ExtractModel.decodeUnit cx input)))]+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+          "no such field ",+          (Model.unName fname),+          " in union"]))) (\f -> f fterm))+      _ -> Left (Errors.DecodingError "expected union")) (ExtractModel.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.Sha256Hash+sha256Hash :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.Sha256Hash+sha256Hash cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermWrap v0 -> Eithers.map (\b -> Format.Sha256Hash b) ((\raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+        Model.TermLiteral v1 -> case v1 of+          Model.LiteralString v2 -> Right v2+          _ -> Left (Errors.DecodingError "expected string literal")+        _ -> Left (Errors.DecodingError "expected literal")) (ExtractModel.stripWithDecodingError cx raw2)) (Model.wrappedTermBody v0))+      _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractModel.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.TermValidationProfile+termValidationProfile :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.TermValidationProfile+termValidationProfile cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermRecord v0 ->+        let fieldMap = ExtractModel.toFieldMap v0+        in (Eithers.bind (ExtractModel.requireField "duplicateBinding" (ExtractModel.decodeMaybe severity) fieldMap cx) (\field_duplicateBinding -> Eithers.bind (ExtractModel.requireField "emptyTermAnnotation" (ExtractModel.decodeMaybe severity) fieldMap cx) (\field_emptyTermAnnotation -> Eithers.bind (ExtractModel.requireField "undefinedVariable" (ExtractModel.decodeMaybe severity) fieldMap cx) (\field_undefinedVariable -> Right (Format.TermValidationProfile {+          Format.termValidationProfileDuplicateBinding = field_duplicateBinding,+          Format.termValidationProfileEmptyTermAnnotation = field_emptyTermAnnotation,+          Format.termValidationProfileUndefinedVariable = field_undefinedVariable})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.TermValidationProfile")) (ExtractModel.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.TypeValidationProfile+typeValidationProfile :: Graph.Graph -> Model.Term -> Either Errors.DecodingError Format.TypeValidationProfile+typeValidationProfile cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Model.TermRecord v0 ->+        let fieldMap = ExtractModel.toFieldMap v0+        in (Eithers.bind (ExtractModel.requireField "emptyAnnotation" (ExtractModel.decodeMaybe severity) fieldMap cx) (\field_emptyAnnotation -> Eithers.bind (ExtractModel.requireField "duplicateField" (ExtractModel.decodeMaybe severity) fieldMap cx) (\field_duplicateField -> Eithers.bind (ExtractModel.requireField "singleVariantUnion" (ExtractModel.decodeMaybe severity) fieldMap cx) (\field_singleVariantUnion -> Right (Format.TypeValidationProfile {+          Format.typeValidationProfileEmptyAnnotation = field_emptyAnnotation,+          Format.typeValidationProfileDuplicateField = field_duplicateField,+          Format.typeValidationProfileSingleVariantUnion = field_singleVariantUnion})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.TypeValidationProfile")) (ExtractModel.stripWithDecodingError cx raw)

@@ -0,0 +1,375 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.build.assembly++module Hydra.Build.Dsl.Assembly where++import qualified Hydra.Build.Assembly as Assembly+import qualified Hydra.Build.Decode.Assembly as DecodeAssembly+import qualified Hydra.Build.Encode.Assembly as EncodeAssembly+import qualified Hydra.Core.Model as Model+import qualified Hydra.Core.Typed as Typed+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)+import qualified Data.Scientific as Sci+import Data.Void++-- | DSL constructor for hydra.build.assembly.AssemblyEntry+assemblyEntry :: Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm Assembly.AssemblyEntryKind -> Typed.TypedTerm [String] -> Typed.TypedTerm Assembly.AssemblyEntry+assemblyEntry sourceTree destTree kind exclude =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "sourceTree"),+          Model.fieldTerm = (Typed.unTypedTerm sourceTree)},+        Model.Field {+          Model.fieldName = (Model.Name "destTree"),+          Model.fieldTerm = (Typed.unTypedTerm destTree)},+        Model.Field {+          Model.fieldName = (Model.Name "kind"),+          Model.fieldTerm = (Typed.unTypedTerm kind)},+        Model.Field {+          Model.fieldName = (Model.Name "exclude"),+          Model.fieldTerm = (Typed.unTypedTerm exclude)}]}))++-- | DSL name token for hydra.build.assembly.AssemblyEntry+assemblyEntryAssemblyEntry :: Typed.TypedName Assembly.AssemblyEntry+assemblyEntryAssemblyEntry = Typed.TypedName (Model.Name "hydra.build.assembly.AssemblyEntry")++-- | DSL accessor for the destTree field of hydra.build.assembly.AssemblyEntry+assemblyEntryDestTree :: Typed.TypedTerm Assembly.AssemblyEntry -> Typed.TypedTerm String+assemblyEntryDestTree x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"),+        Model.projectionFieldName = (Model.Name "destTree")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the exclude field of hydra.build.assembly.AssemblyEntry+assemblyEntryExclude :: Typed.TypedTerm Assembly.AssemblyEntry -> Typed.TypedTerm [String]+assemblyEntryExclude x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"),+        Model.projectionFieldName = (Model.Name "exclude")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the kind field of hydra.build.assembly.AssemblyEntry+assemblyEntryKind :: Typed.TypedTerm Assembly.AssemblyEntry -> Typed.TypedTerm Assembly.AssemblyEntryKind+assemblyEntryKind x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"),+        Model.projectionFieldName = (Model.Name "kind")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.assembly.AssemblyEntryKind+assemblyEntryKindAssemblyEntryKind :: Typed.TypedName Assembly.AssemblyEntryKind+assemblyEntryKindAssemblyEntryKind = Typed.TypedName (Model.Name "hydra.build.assembly.AssemblyEntryKind")++-- | DSL injection for the merge variant of hydra.build.assembly.AssemblyEntryKind+assemblyEntryKindMerge :: Typed.TypedTerm Assembly.AssemblyEntryKind+assemblyEntryKindMerge =+    Typed.TypedTerm (Model.TermInject (Model.Injection {+      Model.injectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntryKind"),+      Model.injectionField = Model.Field {+        Model.fieldName = (Model.Name "merge"),+        Model.fieldTerm = Model.TermUnit}}))++-- | DSL injection for the symlinkDir variant of hydra.build.assembly.AssemblyEntryKind+assemblyEntryKindSymlinkDir :: Typed.TypedTerm Assembly.AssemblyEntryKind+assemblyEntryKindSymlinkDir =+    Typed.TypedTerm (Model.TermInject (Model.Injection {+      Model.injectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntryKind"),+      Model.injectionField = Model.Field {+        Model.fieldName = (Model.Name "symlinkDir"),+        Model.fieldTerm = Model.TermUnit}}))++-- | DSL injection for the symlinkTree variant of hydra.build.assembly.AssemblyEntryKind+assemblyEntryKindSymlinkTree :: Typed.TypedTerm Assembly.AssemblyEntryKind+assemblyEntryKindSymlinkTree =+    Typed.TypedTerm (Model.TermInject (Model.Injection {+      Model.injectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntryKind"),+      Model.injectionField = Model.Field {+        Model.fieldName = (Model.Name "symlinkTree"),+        Model.fieldTerm = Model.TermUnit}}))++-- | DSL injection for the wipeThenCopy variant of hydra.build.assembly.AssemblyEntryKind+assemblyEntryKindWipeThenCopy :: Typed.TypedTerm Assembly.AssemblyEntryKind+assemblyEntryKindWipeThenCopy =+    Typed.TypedTerm (Model.TermInject (Model.Injection {+      Model.injectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntryKind"),+      Model.injectionField = Model.Field {+        Model.fieldName = (Model.Name "wipeThenCopy"),+        Model.fieldTerm = Model.TermUnit}}))++-- | DSL accessor for the sourceTree field of hydra.build.assembly.AssemblyEntry+assemblyEntrySourceTree :: Typed.TypedTerm Assembly.AssemblyEntry -> Typed.TypedTerm String+assemblyEntrySourceTree x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"),+        Model.projectionFieldName = (Model.Name "sourceTree")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the destTree field of hydra.build.assembly.AssemblyEntry+assemblyEntryWithDestTree :: Typed.TypedTerm Assembly.AssemblyEntry -> Typed.TypedTerm String -> Typed.TypedTerm Assembly.AssemblyEntry+assemblyEntryWithDestTree original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "sourceTree"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"),+              Model.projectionFieldName = (Model.Name "sourceTree")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "destTree"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "kind"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"),+              Model.projectionFieldName = (Model.Name "kind")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "exclude"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"),+              Model.projectionFieldName = (Model.Name "exclude")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the exclude field of hydra.build.assembly.AssemblyEntry+assemblyEntryWithExclude :: Typed.TypedTerm Assembly.AssemblyEntry -> Typed.TypedTerm [String] -> Typed.TypedTerm Assembly.AssemblyEntry+assemblyEntryWithExclude original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "sourceTree"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"),+              Model.projectionFieldName = (Model.Name "sourceTree")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "destTree"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"),+              Model.projectionFieldName = (Model.Name "destTree")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "kind"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"),+              Model.projectionFieldName = (Model.Name "kind")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "exclude"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the kind field of hydra.build.assembly.AssemblyEntry+assemblyEntryWithKind :: Typed.TypedTerm Assembly.AssemblyEntry -> Typed.TypedTerm Assembly.AssemblyEntryKind -> Typed.TypedTerm Assembly.AssemblyEntry+assemblyEntryWithKind original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "sourceTree"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"),+              Model.projectionFieldName = (Model.Name "sourceTree")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "destTree"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"),+              Model.projectionFieldName = (Model.Name "destTree")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "kind"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "exclude"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"),+              Model.projectionFieldName = (Model.Name "exclude")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the sourceTree field of hydra.build.assembly.AssemblyEntry+assemblyEntryWithSourceTree :: Typed.TypedTerm Assembly.AssemblyEntry -> Typed.TypedTerm String -> Typed.TypedTerm Assembly.AssemblyEntry+assemblyEntryWithSourceTree original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "sourceTree"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "destTree"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"),+              Model.projectionFieldName = (Model.Name "destTree")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "kind"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"),+              Model.projectionFieldName = (Model.Name "kind")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "exclude"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"),+              Model.projectionFieldName = (Model.Name "exclude")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.build.assembly.AssemblyPlan+assemblyPlan :: Typed.TypedTerm [Assembly.AssemblyEntry] -> Typed.TypedTerm [Assembly.KeepPathEntry] -> Typed.TypedTerm Assembly.AssemblyPlan+assemblyPlan entries keepPaths =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.assembly.AssemblyPlan"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "entries"),+          Model.fieldTerm = (Typed.unTypedTerm entries)},+        Model.Field {+          Model.fieldName = (Model.Name "keepPaths"),+          Model.fieldTerm = (Typed.unTypedTerm keepPaths)}]}))++-- | DSL name token for hydra.build.assembly.AssemblyPlan+assemblyPlanAssemblyPlan :: Typed.TypedName Assembly.AssemblyPlan+assemblyPlanAssemblyPlan = Typed.TypedName (Model.Name "hydra.build.assembly.AssemblyPlan")++-- | DSL accessor for the entries field of hydra.build.assembly.AssemblyPlan+assemblyPlanEntries :: Typed.TypedTerm Assembly.AssemblyPlan -> Typed.TypedTerm [Assembly.AssemblyEntry]+assemblyPlanEntries x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyPlan"),+        Model.projectionFieldName = (Model.Name "entries")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the keepPaths field of hydra.build.assembly.AssemblyPlan+assemblyPlanKeepPaths :: Typed.TypedTerm Assembly.AssemblyPlan -> Typed.TypedTerm [Assembly.KeepPathEntry]+assemblyPlanKeepPaths x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyPlan"),+        Model.projectionFieldName = (Model.Name "keepPaths")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the entries field of hydra.build.assembly.AssemblyPlan+assemblyPlanWithEntries :: Typed.TypedTerm Assembly.AssemblyPlan -> Typed.TypedTerm [Assembly.AssemblyEntry] -> Typed.TypedTerm Assembly.AssemblyPlan+assemblyPlanWithEntries original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.assembly.AssemblyPlan"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "entries"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "keepPaths"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyPlan"),+              Model.projectionFieldName = (Model.Name "keepPaths")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the keepPaths field of hydra.build.assembly.AssemblyPlan+assemblyPlanWithKeepPaths :: Typed.TypedTerm Assembly.AssemblyPlan -> Typed.TypedTerm [Assembly.KeepPathEntry] -> Typed.TypedTerm Assembly.AssemblyPlan+assemblyPlanWithKeepPaths original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.assembly.AssemblyPlan"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "entries"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.assembly.AssemblyPlan"),+              Model.projectionFieldName = (Model.Name "entries")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "keepPaths"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.build.assembly.KeepPathEntry+keepPathEntry :: Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm Assembly.KeepPathEntry+keepPathEntry sourceSetDir relPath =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.assembly.KeepPathEntry"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "sourceSetDir"),+          Model.fieldTerm = (Typed.unTypedTerm sourceSetDir)},+        Model.Field {+          Model.fieldName = (Model.Name "relPath"),+          Model.fieldTerm = (Typed.unTypedTerm relPath)}]}))++-- | DSL name token for hydra.build.assembly.KeepPathEntry+keepPathEntryKeepPathEntry :: Typed.TypedName Assembly.KeepPathEntry+keepPathEntryKeepPathEntry = Typed.TypedName (Model.Name "hydra.build.assembly.KeepPathEntry")++-- | DSL accessor for the relPath field of hydra.build.assembly.KeepPathEntry+keepPathEntryRelPath :: Typed.TypedTerm Assembly.KeepPathEntry -> Typed.TypedTerm String+keepPathEntryRelPath x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.assembly.KeepPathEntry"),+        Model.projectionFieldName = (Model.Name "relPath")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the sourceSetDir field of hydra.build.assembly.KeepPathEntry+keepPathEntrySourceSetDir :: Typed.TypedTerm Assembly.KeepPathEntry -> Typed.TypedTerm String+keepPathEntrySourceSetDir x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.assembly.KeepPathEntry"),+        Model.projectionFieldName = (Model.Name "sourceSetDir")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the relPath field of hydra.build.assembly.KeepPathEntry+keepPathEntryWithRelPath :: Typed.TypedTerm Assembly.KeepPathEntry -> Typed.TypedTerm String -> Typed.TypedTerm Assembly.KeepPathEntry+keepPathEntryWithRelPath original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.assembly.KeepPathEntry"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "sourceSetDir"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.assembly.KeepPathEntry"),+              Model.projectionFieldName = (Model.Name "sourceSetDir")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "relPath"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the sourceSetDir field of hydra.build.assembly.KeepPathEntry+keepPathEntryWithSourceSetDir :: Typed.TypedTerm Assembly.KeepPathEntry -> Typed.TypedTerm String -> Typed.TypedTerm Assembly.KeepPathEntry+keepPathEntryWithSourceSetDir original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.assembly.KeepPathEntry"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "sourceSetDir"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "relPath"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.assembly.KeepPathEntry"),+              Model.projectionFieldName = (Model.Name "relPath")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

@@ -0,0 +1,597 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.build.benchresult++module Hydra.Build.Dsl.Benchresult where++import qualified Hydra.Build.Benchresult as Benchresult+import qualified Hydra.Build.Decode.Benchresult as DecodeBenchresult+import qualified Hydra.Build.Encode.Benchresult as EncodeBenchresult+import qualified Hydra.Core.Model as Model+import qualified Hydra.Core.Typed as Typed+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)+import qualified Data.Scientific as Sci+import Data.Void+import qualified Data.Map as M++-- | DSL constructor for hydra.build.benchresult.BenchMetadata+benchMetadata :: Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm Benchresult.BenchMetadata+benchMetadata timestamp language branch commit commitMessage =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "timestamp"),+          Model.fieldTerm = (Typed.unTypedTerm timestamp)},+        Model.Field {+          Model.fieldName = (Model.Name "language"),+          Model.fieldTerm = (Typed.unTypedTerm language)},+        Model.Field {+          Model.fieldName = (Model.Name "branch"),+          Model.fieldTerm = (Typed.unTypedTerm branch)},+        Model.Field {+          Model.fieldName = (Model.Name "commit"),+          Model.fieldTerm = (Typed.unTypedTerm commit)},+        Model.Field {+          Model.fieldName = (Model.Name "commitMessage"),+          Model.fieldTerm = (Typed.unTypedTerm commitMessage)}]}))++-- | DSL name token for hydra.build.benchresult.BenchMetadata+benchMetadataBenchMetadata :: Typed.TypedName Benchresult.BenchMetadata+benchMetadataBenchMetadata = Typed.TypedName (Model.Name "hydra.build.benchresult.BenchMetadata")++-- | DSL accessor for the branch field of hydra.build.benchresult.BenchMetadata+benchMetadataBranch :: Typed.TypedTerm Benchresult.BenchMetadata -> Typed.TypedTerm String+benchMetadataBranch x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+        Model.projectionFieldName = (Model.Name "branch")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the commit field of hydra.build.benchresult.BenchMetadata+benchMetadataCommit :: Typed.TypedTerm Benchresult.BenchMetadata -> Typed.TypedTerm String+benchMetadataCommit x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+        Model.projectionFieldName = (Model.Name "commit")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the commitMessage field of hydra.build.benchresult.BenchMetadata+benchMetadataCommitMessage :: Typed.TypedTerm Benchresult.BenchMetadata -> Typed.TypedTerm String+benchMetadataCommitMessage x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+        Model.projectionFieldName = (Model.Name "commitMessage")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the language field of hydra.build.benchresult.BenchMetadata+benchMetadataLanguage :: Typed.TypedTerm Benchresult.BenchMetadata -> Typed.TypedTerm String+benchMetadataLanguage x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+        Model.projectionFieldName = (Model.Name "language")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the timestamp field of hydra.build.benchresult.BenchMetadata+benchMetadataTimestamp :: Typed.TypedTerm Benchresult.BenchMetadata -> Typed.TypedTerm String+benchMetadataTimestamp x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+        Model.projectionFieldName = (Model.Name "timestamp")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the branch field of hydra.build.benchresult.BenchMetadata+benchMetadataWithBranch :: Typed.TypedTerm Benchresult.BenchMetadata -> Typed.TypedTerm String -> Typed.TypedTerm Benchresult.BenchMetadata+benchMetadataWithBranch original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "timestamp"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+              Model.projectionFieldName = (Model.Name "timestamp")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "language"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+              Model.projectionFieldName = (Model.Name "language")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "branch"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "commit"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+              Model.projectionFieldName = (Model.Name "commit")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "commitMessage"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+              Model.projectionFieldName = (Model.Name "commitMessage")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the commit field of hydra.build.benchresult.BenchMetadata+benchMetadataWithCommit :: Typed.TypedTerm Benchresult.BenchMetadata -> Typed.TypedTerm String -> Typed.TypedTerm Benchresult.BenchMetadata+benchMetadataWithCommit original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "timestamp"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+              Model.projectionFieldName = (Model.Name "timestamp")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "language"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+              Model.projectionFieldName = (Model.Name "language")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "branch"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+              Model.projectionFieldName = (Model.Name "branch")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "commit"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "commitMessage"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+              Model.projectionFieldName = (Model.Name "commitMessage")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the commitMessage field of hydra.build.benchresult.BenchMetadata+benchMetadataWithCommitMessage :: Typed.TypedTerm Benchresult.BenchMetadata -> Typed.TypedTerm String -> Typed.TypedTerm Benchresult.BenchMetadata+benchMetadataWithCommitMessage original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "timestamp"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+              Model.projectionFieldName = (Model.Name "timestamp")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "language"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+              Model.projectionFieldName = (Model.Name "language")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "branch"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+              Model.projectionFieldName = (Model.Name "branch")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "commit"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+              Model.projectionFieldName = (Model.Name "commit")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "commitMessage"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the language field of hydra.build.benchresult.BenchMetadata+benchMetadataWithLanguage :: Typed.TypedTerm Benchresult.BenchMetadata -> Typed.TypedTerm String -> Typed.TypedTerm Benchresult.BenchMetadata+benchMetadataWithLanguage original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "timestamp"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+              Model.projectionFieldName = (Model.Name "timestamp")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "language"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "branch"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+              Model.projectionFieldName = (Model.Name "branch")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "commit"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+              Model.projectionFieldName = (Model.Name "commit")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "commitMessage"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+              Model.projectionFieldName = (Model.Name "commitMessage")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the timestamp field of hydra.build.benchresult.BenchMetadata+benchMetadataWithTimestamp :: Typed.TypedTerm Benchresult.BenchMetadata -> Typed.TypedTerm String -> Typed.TypedTerm Benchresult.BenchMetadata+benchMetadataWithTimestamp original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "timestamp"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "language"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+              Model.projectionFieldName = (Model.Name "language")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "branch"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+              Model.projectionFieldName = (Model.Name "branch")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "commit"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+              Model.projectionFieldName = (Model.Name "commit")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "commitMessage"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+              Model.projectionFieldName = (Model.Name "commitMessage")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.build.benchresult.GenBenchResult+genBenchResult :: Typed.TypedTerm String -> Typed.TypedTerm Int -> Typed.TypedTerm (M.Map String Benchresult.HostResult) -> Typed.TypedTerm (Maybe Benchresult.BenchMetadata) -> Typed.TypedTerm Benchresult.GenBenchResult+genBenchResult target runs hosts metadata =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "target"),+          Model.fieldTerm = (Typed.unTypedTerm target)},+        Model.Field {+          Model.fieldName = (Model.Name "runs"),+          Model.fieldTerm = (Typed.unTypedTerm runs)},+        Model.Field {+          Model.fieldName = (Model.Name "hosts"),+          Model.fieldTerm = (Typed.unTypedTerm hosts)},+        Model.Field {+          Model.fieldName = (Model.Name "metadata"),+          Model.fieldTerm = (Typed.unTypedTerm metadata)}]}))++-- | DSL name token for hydra.build.benchresult.GenBenchResult+genBenchResultGenBenchResult :: Typed.TypedName Benchresult.GenBenchResult+genBenchResultGenBenchResult = Typed.TypedName (Model.Name "hydra.build.benchresult.GenBenchResult")++-- | DSL accessor for the hosts field of hydra.build.benchresult.GenBenchResult+genBenchResultHosts :: Typed.TypedTerm Benchresult.GenBenchResult -> Typed.TypedTerm (M.Map String Benchresult.HostResult)+genBenchResultHosts x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"),+        Model.projectionFieldName = (Model.Name "hosts")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the metadata field of hydra.build.benchresult.GenBenchResult+genBenchResultMetadata :: Typed.TypedTerm Benchresult.GenBenchResult -> Typed.TypedTerm (Maybe Benchresult.BenchMetadata)+genBenchResultMetadata x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"),+        Model.projectionFieldName = (Model.Name "metadata")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the runs field of hydra.build.benchresult.GenBenchResult+genBenchResultRuns :: Typed.TypedTerm Benchresult.GenBenchResult -> Typed.TypedTerm Int+genBenchResultRuns x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"),+        Model.projectionFieldName = (Model.Name "runs")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the target field of hydra.build.benchresult.GenBenchResult+genBenchResultTarget :: Typed.TypedTerm Benchresult.GenBenchResult -> Typed.TypedTerm String+genBenchResultTarget x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"),+        Model.projectionFieldName = (Model.Name "target")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the hosts field of hydra.build.benchresult.GenBenchResult+genBenchResultWithHosts :: Typed.TypedTerm Benchresult.GenBenchResult -> Typed.TypedTerm (M.Map String Benchresult.HostResult) -> Typed.TypedTerm Benchresult.GenBenchResult+genBenchResultWithHosts original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "target"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"),+              Model.projectionFieldName = (Model.Name "target")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "runs"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"),+              Model.projectionFieldName = (Model.Name "runs")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "hosts"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "metadata"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"),+              Model.projectionFieldName = (Model.Name "metadata")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the metadata field of hydra.build.benchresult.GenBenchResult+genBenchResultWithMetadata :: Typed.TypedTerm Benchresult.GenBenchResult -> Typed.TypedTerm (Maybe Benchresult.BenchMetadata) -> Typed.TypedTerm Benchresult.GenBenchResult+genBenchResultWithMetadata original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "target"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"),+              Model.projectionFieldName = (Model.Name "target")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "runs"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"),+              Model.projectionFieldName = (Model.Name "runs")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "hosts"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"),+              Model.projectionFieldName = (Model.Name "hosts")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "metadata"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the runs field of hydra.build.benchresult.GenBenchResult+genBenchResultWithRuns :: Typed.TypedTerm Benchresult.GenBenchResult -> Typed.TypedTerm Int -> Typed.TypedTerm Benchresult.GenBenchResult+genBenchResultWithRuns original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "target"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"),+              Model.projectionFieldName = (Model.Name "target")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "runs"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "hosts"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"),+              Model.projectionFieldName = (Model.Name "hosts")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "metadata"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"),+              Model.projectionFieldName = (Model.Name "metadata")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the target field of hydra.build.benchresult.GenBenchResult+genBenchResultWithTarget :: Typed.TypedTerm Benchresult.GenBenchResult -> Typed.TypedTerm String -> Typed.TypedTerm Benchresult.GenBenchResult+genBenchResultWithTarget original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "target"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "runs"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"),+              Model.projectionFieldName = (Model.Name "runs")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "hosts"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"),+              Model.projectionFieldName = (Model.Name "hosts")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "metadata"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"),+              Model.projectionFieldName = (Model.Name "metadata")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.build.benchresult.HostResult+hostResult :: Typed.TypedTerm Int -> Typed.TypedTerm (M.Map String Benchresult.RunStats) -> Typed.TypedTerm Benchresult.HostResult+hostResult setupMs packages =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.benchresult.HostResult"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "setupMs"),+          Model.fieldTerm = (Typed.unTypedTerm setupMs)},+        Model.Field {+          Model.fieldName = (Model.Name "packages"),+          Model.fieldTerm = (Typed.unTypedTerm packages)}]}))++-- | DSL name token for hydra.build.benchresult.HostResult+hostResultHostResult :: Typed.TypedName Benchresult.HostResult+hostResultHostResult = Typed.TypedName (Model.Name "hydra.build.benchresult.HostResult")++-- | DSL accessor for the packages field of hydra.build.benchresult.HostResult+hostResultPackages :: Typed.TypedTerm Benchresult.HostResult -> Typed.TypedTerm (M.Map String Benchresult.RunStats)+hostResultPackages x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.benchresult.HostResult"),+        Model.projectionFieldName = (Model.Name "packages")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the setupMs field of hydra.build.benchresult.HostResult+hostResultSetupMs :: Typed.TypedTerm Benchresult.HostResult -> Typed.TypedTerm Int+hostResultSetupMs x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.benchresult.HostResult"),+        Model.projectionFieldName = (Model.Name "setupMs")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the packages field of hydra.build.benchresult.HostResult+hostResultWithPackages :: Typed.TypedTerm Benchresult.HostResult -> Typed.TypedTerm (M.Map String Benchresult.RunStats) -> Typed.TypedTerm Benchresult.HostResult+hostResultWithPackages original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.benchresult.HostResult"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "setupMs"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.HostResult"),+              Model.projectionFieldName = (Model.Name "setupMs")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "packages"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the setupMs field of hydra.build.benchresult.HostResult+hostResultWithSetupMs :: Typed.TypedTerm Benchresult.HostResult -> Typed.TypedTerm Int -> Typed.TypedTerm Benchresult.HostResult+hostResultWithSetupMs original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.benchresult.HostResult"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "setupMs"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "packages"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.HostResult"),+              Model.projectionFieldName = (Model.Name "packages")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.build.benchresult.RunStats+runStats :: Typed.TypedTerm [Int] -> Typed.TypedTerm Int -> Typed.TypedTerm Benchresult.RunStats+runStats runsMs medianMs =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.benchresult.RunStats"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "runsMs"),+          Model.fieldTerm = (Typed.unTypedTerm runsMs)},+        Model.Field {+          Model.fieldName = (Model.Name "medianMs"),+          Model.fieldTerm = (Typed.unTypedTerm medianMs)}]}))++-- | DSL accessor for the medianMs field of hydra.build.benchresult.RunStats+runStatsMedianMs :: Typed.TypedTerm Benchresult.RunStats -> Typed.TypedTerm Int+runStatsMedianMs x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.benchresult.RunStats"),+        Model.projectionFieldName = (Model.Name "medianMs")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.benchresult.RunStats+runStatsRunStats :: Typed.TypedName Benchresult.RunStats+runStatsRunStats = Typed.TypedName (Model.Name "hydra.build.benchresult.RunStats")++-- | DSL accessor for the runsMs field of hydra.build.benchresult.RunStats+runStatsRunsMs :: Typed.TypedTerm Benchresult.RunStats -> Typed.TypedTerm [Int]+runStatsRunsMs x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.benchresult.RunStats"),+        Model.projectionFieldName = (Model.Name "runsMs")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the medianMs field of hydra.build.benchresult.RunStats+runStatsWithMedianMs :: Typed.TypedTerm Benchresult.RunStats -> Typed.TypedTerm Int -> Typed.TypedTerm Benchresult.RunStats+runStatsWithMedianMs original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.benchresult.RunStats"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "runsMs"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.RunStats"),+              Model.projectionFieldName = (Model.Name "runsMs")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "medianMs"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the runsMs field of hydra.build.benchresult.RunStats+runStatsWithRunsMs :: Typed.TypedTerm Benchresult.RunStats -> Typed.TypedTerm [Int] -> Typed.TypedTerm Benchresult.RunStats+runStatsWithRunsMs original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.benchresult.RunStats"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "runsMs"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "medianMs"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.benchresult.RunStats"),+              Model.projectionFieldName = (Model.Name "medianMs")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

@@ -0,0 +1,425 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.build.comparereport++module Hydra.Build.Dsl.Comparereport where++import qualified Hydra.Build.Comparereport as Comparereport+import qualified Hydra.Build.Decode.Comparereport as DecodeComparereport+import qualified Hydra.Build.Encode.Comparereport as EncodeComparereport+import qualified Hydra.Core.Model as Model+import qualified Hydra.Core.Typed as Typed+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)+import qualified Data.Scientific as Sci+import Data.Void++-- | DSL constructor for hydra.build.comparereport.CompareReport+compareReport :: Typed.TypedTerm [Comparereport.ModuleCompare] -> Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm Comparereport.CompareReport+compareReport rows byteEqCount total =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.comparereport.CompareReport"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "rows"),+          Model.fieldTerm = (Typed.unTypedTerm rows)},+        Model.Field {+          Model.fieldName = (Model.Name "byteEqCount"),+          Model.fieldTerm = (Typed.unTypedTerm byteEqCount)},+        Model.Field {+          Model.fieldName = (Model.Name "total"),+          Model.fieldTerm = (Typed.unTypedTerm total)}]}))++-- | DSL accessor for the byteEqCount field of hydra.build.comparereport.CompareReport+compareReportByteEqCount :: Typed.TypedTerm Comparereport.CompareReport -> Typed.TypedTerm Int+compareReportByteEqCount x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.comparereport.CompareReport"),+        Model.projectionFieldName = (Model.Name "byteEqCount")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.comparereport.CompareReport+compareReportCompareReport :: Typed.TypedName Comparereport.CompareReport+compareReportCompareReport = Typed.TypedName (Model.Name "hydra.build.comparereport.CompareReport")++-- | DSL accessor for the rows field of hydra.build.comparereport.CompareReport+compareReportRows :: Typed.TypedTerm Comparereport.CompareReport -> Typed.TypedTerm [Comparereport.ModuleCompare]+compareReportRows x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.comparereport.CompareReport"),+        Model.projectionFieldName = (Model.Name "rows")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the total field of hydra.build.comparereport.CompareReport+compareReportTotal :: Typed.TypedTerm Comparereport.CompareReport -> Typed.TypedTerm Int+compareReportTotal x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.comparereport.CompareReport"),+        Model.projectionFieldName = (Model.Name "total")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the byteEqCount field of hydra.build.comparereport.CompareReport+compareReportWithByteEqCount :: Typed.TypedTerm Comparereport.CompareReport -> Typed.TypedTerm Int -> Typed.TypedTerm Comparereport.CompareReport+compareReportWithByteEqCount original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.comparereport.CompareReport"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "rows"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.comparereport.CompareReport"),+              Model.projectionFieldName = (Model.Name "rows")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "byteEqCount"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "total"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.comparereport.CompareReport"),+              Model.projectionFieldName = (Model.Name "total")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the rows field of hydra.build.comparereport.CompareReport+compareReportWithRows :: Typed.TypedTerm Comparereport.CompareReport -> Typed.TypedTerm [Comparereport.ModuleCompare] -> Typed.TypedTerm Comparereport.CompareReport+compareReportWithRows original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.comparereport.CompareReport"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "rows"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "byteEqCount"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.comparereport.CompareReport"),+              Model.projectionFieldName = (Model.Name "byteEqCount")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "total"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.comparereport.CompareReport"),+              Model.projectionFieldName = (Model.Name "total")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the total field of hydra.build.comparereport.CompareReport+compareReportWithTotal :: Typed.TypedTerm Comparereport.CompareReport -> Typed.TypedTerm Int -> Typed.TypedTerm Comparereport.CompareReport+compareReportWithTotal original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.comparereport.CompareReport"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "rows"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.comparereport.CompareReport"),+              Model.projectionFieldName = (Model.Name "rows")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "byteEqCount"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.comparereport.CompareReport"),+              Model.projectionFieldName = (Model.Name "byteEqCount")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "total"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL injection for the byteEq variant of hydra.build.comparereport.CompareStatus+compareStatusByteEq :: Typed.TypedTerm Comparereport.CompareStatus+compareStatusByteEq =+    Typed.TypedTerm (Model.TermInject (Model.Injection {+      Model.injectionTypeName = (Model.Name "hydra.build.comparereport.CompareStatus"),+      Model.injectionField = Model.Field {+        Model.fieldName = (Model.Name "byteEq"),+        Model.fieldTerm = Model.TermUnit}}))++-- | DSL name token for hydra.build.comparereport.CompareStatus+compareStatusCompareStatus :: Typed.TypedName Comparereport.CompareStatus+compareStatusCompareStatus = Typed.TypedName (Model.Name "hydra.build.comparereport.CompareStatus")++-- | DSL injection for the differ variant of hydra.build.comparereport.CompareStatus+compareStatusDiffer :: Typed.TypedTerm Comparereport.CompareStatus+compareStatusDiffer =+    Typed.TypedTerm (Model.TermInject (Model.Injection {+      Model.injectionTypeName = (Model.Name "hydra.build.comparereport.CompareStatus"),+      Model.injectionField = Model.Field {+        Model.fieldName = (Model.Name "differ"),+        Model.fieldTerm = Model.TermUnit}}))++-- | DSL injection for the missing variant of hydra.build.comparereport.CompareStatus+compareStatusMissing :: Typed.TypedTerm Comparereport.CompareStatus+compareStatusMissing =+    Typed.TypedTerm (Model.TermInject (Model.Injection {+      Model.injectionTypeName = (Model.Name "hydra.build.comparereport.CompareStatus"),+      Model.injectionField = Model.Field {+        Model.fieldName = (Model.Name "missing"),+        Model.fieldTerm = Model.TermUnit}}))++-- | DSL constructor for hydra.build.comparereport.ModuleCompare+moduleCompare :: Typed.TypedTerm String -> Typed.TypedTerm Comparereport.CompareStatus -> Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm Comparereport.ModuleCompare+moduleCompare module_ status ourSize canonSize diffLines =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "module"),+          Model.fieldTerm = (Typed.unTypedTerm module_)},+        Model.Field {+          Model.fieldName = (Model.Name "status"),+          Model.fieldTerm = (Typed.unTypedTerm status)},+        Model.Field {+          Model.fieldName = (Model.Name "ourSize"),+          Model.fieldTerm = (Typed.unTypedTerm ourSize)},+        Model.Field {+          Model.fieldName = (Model.Name "canonSize"),+          Model.fieldTerm = (Typed.unTypedTerm canonSize)},+        Model.Field {+          Model.fieldName = (Model.Name "diffLines"),+          Model.fieldTerm = (Typed.unTypedTerm diffLines)}]}))++-- | DSL accessor for the canonSize field of hydra.build.comparereport.ModuleCompare+moduleCompareCanonSize :: Typed.TypedTerm Comparereport.ModuleCompare -> Typed.TypedTerm Int+moduleCompareCanonSize x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"),+        Model.projectionFieldName = (Model.Name "canonSize")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the diffLines field of hydra.build.comparereport.ModuleCompare+moduleCompareDiffLines :: Typed.TypedTerm Comparereport.ModuleCompare -> Typed.TypedTerm Int+moduleCompareDiffLines x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"),+        Model.projectionFieldName = (Model.Name "diffLines")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the module field of hydra.build.comparereport.ModuleCompare+moduleCompareModule :: Typed.TypedTerm Comparereport.ModuleCompare -> Typed.TypedTerm String+moduleCompareModule x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"),+        Model.projectionFieldName = (Model.Name "module")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.comparereport.ModuleCompare+moduleCompareModuleCompare :: Typed.TypedName Comparereport.ModuleCompare+moduleCompareModuleCompare = Typed.TypedName (Model.Name "hydra.build.comparereport.ModuleCompare")++-- | DSL accessor for the ourSize field of hydra.build.comparereport.ModuleCompare+moduleCompareOurSize :: Typed.TypedTerm Comparereport.ModuleCompare -> Typed.TypedTerm Int+moduleCompareOurSize x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"),+        Model.projectionFieldName = (Model.Name "ourSize")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the status field of hydra.build.comparereport.ModuleCompare+moduleCompareStatus :: Typed.TypedTerm Comparereport.ModuleCompare -> Typed.TypedTerm Comparereport.CompareStatus+moduleCompareStatus x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"),+        Model.projectionFieldName = (Model.Name "status")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the canonSize field of hydra.build.comparereport.ModuleCompare+moduleCompareWithCanonSize :: Typed.TypedTerm Comparereport.ModuleCompare -> Typed.TypedTerm Int -> Typed.TypedTerm Comparereport.ModuleCompare+moduleCompareWithCanonSize original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "module"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"),+              Model.projectionFieldName = (Model.Name "module")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "status"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"),+              Model.projectionFieldName = (Model.Name "status")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "ourSize"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"),+              Model.projectionFieldName = (Model.Name "ourSize")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "canonSize"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "diffLines"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"),+              Model.projectionFieldName = (Model.Name "diffLines")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the diffLines field of hydra.build.comparereport.ModuleCompare+moduleCompareWithDiffLines :: Typed.TypedTerm Comparereport.ModuleCompare -> Typed.TypedTerm Int -> Typed.TypedTerm Comparereport.ModuleCompare+moduleCompareWithDiffLines original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "module"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"),+              Model.projectionFieldName = (Model.Name "module")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "status"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"),+              Model.projectionFieldName = (Model.Name "status")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "ourSize"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"),+              Model.projectionFieldName = (Model.Name "ourSize")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "canonSize"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"),+              Model.projectionFieldName = (Model.Name "canonSize")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "diffLines"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the module field of hydra.build.comparereport.ModuleCompare+moduleCompareWithModule :: Typed.TypedTerm Comparereport.ModuleCompare -> Typed.TypedTerm String -> Typed.TypedTerm Comparereport.ModuleCompare+moduleCompareWithModule original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "module"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "status"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"),+              Model.projectionFieldName = (Model.Name "status")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "ourSize"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"),+              Model.projectionFieldName = (Model.Name "ourSize")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "canonSize"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"),+              Model.projectionFieldName = (Model.Name "canonSize")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "diffLines"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"),+              Model.projectionFieldName = (Model.Name "diffLines")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the ourSize field of hydra.build.comparereport.ModuleCompare+moduleCompareWithOurSize :: Typed.TypedTerm Comparereport.ModuleCompare -> Typed.TypedTerm Int -> Typed.TypedTerm Comparereport.ModuleCompare+moduleCompareWithOurSize original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "module"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"),+              Model.projectionFieldName = (Model.Name "module")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "status"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"),+              Model.projectionFieldName = (Model.Name "status")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "ourSize"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "canonSize"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"),+              Model.projectionFieldName = (Model.Name "canonSize")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "diffLines"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"),+              Model.projectionFieldName = (Model.Name "diffLines")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the status field of hydra.build.comparereport.ModuleCompare+moduleCompareWithStatus :: Typed.TypedTerm Comparereport.ModuleCompare -> Typed.TypedTerm Comparereport.CompareStatus -> Typed.TypedTerm Comparereport.ModuleCompare+moduleCompareWithStatus original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "module"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"),+              Model.projectionFieldName = (Model.Name "module")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "status"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "ourSize"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"),+              Model.projectionFieldName = (Model.Name "ourSize")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "canonSize"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"),+              Model.projectionFieldName = (Model.Name "canonSize")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "diffLines"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.comparereport.ModuleCompare"),+              Model.projectionFieldName = (Model.Name "diffLines")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

@@ -0,0 +1,4108 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.build.format++module Hydra.Build.Dsl.Format where++import qualified Hydra.Build.Decode.Format as DecodeFormat+import qualified Hydra.Build.Encode.Format as EncodeFormat+import qualified Hydra.Build.Format as Format+import qualified Hydra.Core.Dsl.Packaging as DslPackaging+import qualified Hydra.Core.Model as Model+import qualified Hydra.Core.Packaging as Packaging+import qualified Hydra.Core.Typed as Typed+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)+import qualified Data.Scientific as Sci+import Data.Void+import qualified Data.Map as M++-- | DSL constructor for hydra.build.format.DefinitionNameConventionProfile+definitionNameConventionProfile :: Typed.TypedTerm Format.Severity -> Typed.TypedTerm Bool -> Typed.TypedTerm Format.DefinitionNameConventionProfile+definitionNameConventionProfile severity allowUnderscores =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.DefinitionNameConventionProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "severity"),+          Model.fieldTerm = (Typed.unTypedTerm severity)},+        Model.Field {+          Model.fieldName = (Model.Name "allowUnderscores"),+          Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionNameConventionProfile"),+        Model.projectionFieldName = (Model.Name "allowUnderscores")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.format.DefinitionNameConventionProfile+definitionNameConventionProfileDefinitionNameConventionProfile :: Typed.TypedName Format.DefinitionNameConventionProfile+definitionNameConventionProfileDefinitionNameConventionProfile =+    Typed.TypedName (Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionNameConventionProfile"),+        Model.projectionFieldName = (Model.Name "severity")})),+      Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.DefinitionNameConventionProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "severity"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionNameConventionProfile"),+              Model.projectionFieldName = (Model.Name "severity")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "allowUnderscores"),+          Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.DefinitionNameConventionProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "severity"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "allowUnderscores"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionNameConventionProfile"),+              Model.projectionFieldName = (Model.Name "allowUnderscores")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "hasDescription"),+          Model.fieldTerm = (Typed.unTypedTerm hasDescription)},+        Model.Field {+          Model.fieldName = (Model.Name "ordering"),+          Model.fieldTerm = (Typed.unTypedTerm ordering)},+        Model.Field {+          Model.fieldName = (Model.Name "nameConvention"),+          Model.fieldTerm = (Typed.unTypedTerm nameConvention)},+        Model.Field {+          Model.fieldName = (Model.Name "notInModuleName"),+          Model.fieldTerm = (Typed.unTypedTerm notInModuleName)},+        Model.Field {+          Model.fieldName = (Model.Name "duplicateName"),+          Model.fieldTerm = (Typed.unTypedTerm duplicateName)}]}))++-- | DSL name token for hydra.build.format.DefinitionValidationProfile+definitionValidationProfileDefinitionValidationProfile :: Typed.TypedName Format.DefinitionValidationProfile+definitionValidationProfileDefinitionValidationProfile =+    Typed.TypedName (Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"),+        Model.projectionFieldName = (Model.Name "duplicateName")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"),+        Model.projectionFieldName = (Model.Name "hasDescription")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"),+        Model.projectionFieldName = (Model.Name "nameConvention")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"),+        Model.projectionFieldName = (Model.Name "notInModuleName")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"),+        Model.projectionFieldName = (Model.Name "ordering")})),+      Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "hasDescription"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"),+              Model.projectionFieldName = (Model.Name "hasDescription")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "ordering"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"),+              Model.projectionFieldName = (Model.Name "ordering")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "nameConvention"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"),+              Model.projectionFieldName = (Model.Name "nameConvention")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "notInModuleName"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"),+              Model.projectionFieldName = (Model.Name "notInModuleName")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "duplicateName"),+          Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "hasDescription"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "ordering"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"),+              Model.projectionFieldName = (Model.Name "ordering")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "nameConvention"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"),+              Model.projectionFieldName = (Model.Name "nameConvention")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "notInModuleName"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"),+              Model.projectionFieldName = (Model.Name "notInModuleName")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "duplicateName"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"),+              Model.projectionFieldName = (Model.Name "duplicateName")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "hasDescription"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"),+              Model.projectionFieldName = (Model.Name "hasDescription")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "ordering"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"),+              Model.projectionFieldName = (Model.Name "ordering")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "nameConvention"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "notInModuleName"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"),+              Model.projectionFieldName = (Model.Name "notInModuleName")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "duplicateName"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"),+              Model.projectionFieldName = (Model.Name "duplicateName")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "hasDescription"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"),+              Model.projectionFieldName = (Model.Name "hasDescription")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "ordering"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"),+              Model.projectionFieldName = (Model.Name "ordering")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "nameConvention"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"),+              Model.projectionFieldName = (Model.Name "nameConvention")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "notInModuleName"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "duplicateName"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"),+              Model.projectionFieldName = (Model.Name "duplicateName")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "hasDescription"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"),+              Model.projectionFieldName = (Model.Name "hasDescription")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "ordering"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "nameConvention"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"),+              Model.projectionFieldName = (Model.Name "nameConvention")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "notInModuleName"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"),+              Model.projectionFieldName = (Model.Name "notInModuleName")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "duplicateName"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.DefinitionValidationProfile"),+              Model.projectionFieldName = (Model.Name "duplicateName")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.DigestEntry"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "kind"),+          Model.fieldTerm = (Typed.unTypedTerm kind)},+        Model.Field {+          Model.fieldName = (Model.Name "hash"),+          Model.fieldTerm = (Typed.unTypedTerm hash)}]}))++-- | DSL name token for hydra.build.format.DigestEntry+digestEntryDigestEntry :: Typed.TypedName Format.DigestEntry+digestEntryDigestEntry = Typed.TypedName (Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.DigestEntry"),+        Model.projectionFieldName = (Model.Name "hash")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.DigestEntry"),+        Model.projectionFieldName = (Model.Name "kind")})),+      Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.DigestEntry"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "kind"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.DigestEntry"),+              Model.projectionFieldName = (Model.Name "kind")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "hash"),+          Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.DigestEntry"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "kind"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "hash"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.DigestEntry"),+              Model.projectionFieldName = (Model.Name "hash")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL name token for hydra.build.format.DigestKind+digestKindDigestKind :: Typed.TypedName Format.DigestKind+digestKindDigestKind = Typed.TypedName (Model.Name "hydra.build.format.DigestKind")++-- | DSL injection for the dslSource variant of hydra.build.format.DigestKind+digestKindDslSource :: Typed.TypedTerm Format.DigestKind+digestKindDslSource =+    Typed.TypedTerm (Model.TermInject (Model.Injection {+      Model.injectionTypeName = (Model.Name "hydra.build.format.DigestKind"),+      Model.injectionField = Model.Field {+        Model.fieldName = (Model.Name "dslSource"),+        Model.fieldTerm = Model.TermUnit}}))++-- | DSL injection for the jsonFile variant of hydra.build.format.DigestKind+digestKindJsonFile :: Typed.TypedTerm Format.DigestKind+digestKindJsonFile =+    Typed.TypedTerm (Model.TermInject (Model.Injection {+      Model.injectionTypeName = (Model.Name "hydra.build.format.DigestKind"),+      Model.injectionField = Model.Field {+        Model.fieldName = (Model.Name "jsonFile"),+        Model.fieldTerm = Model.TermUnit}}))++-- | DSL injection for the other variant of hydra.build.format.DigestKind+digestKindOther :: Typed.TypedTerm Format.DigestKind+digestKindOther =+    Typed.TypedTerm (Model.TermInject (Model.Injection {+      Model.injectionTypeName = (Model.Name "hydra.build.format.DigestKind"),+      Model.injectionField = Model.Field {+        Model.fieldName = (Model.Name "other"),+        Model.fieldTerm = Model.TermUnit}}))++-- | DSL injection for the runtimeFile variant of hydra.build.format.DigestKind+digestKindRuntimeFile :: Typed.TypedTerm Format.DigestKind+digestKindRuntimeFile =+    Typed.TypedTerm (Model.TermInject (Model.Injection {+      Model.injectionTypeName = (Model.Name "hydra.build.format.DigestKind"),+      Model.injectionField = Model.Field {+        Model.fieldName = (Model.Name "runtimeFile"),+        Model.fieldTerm = Model.TermUnit}}))++-- | DSL injection for the targetFile variant of hydra.build.format.DigestKind+digestKindTargetFile :: Typed.TypedTerm Format.DigestKind+digestKindTargetFile =+    Typed.TypedTerm (Model.TermInject (Model.Injection {+      Model.injectionTypeName = (Model.Name "hydra.build.format.DigestKind"),+      Model.injectionField = Model.Field {+        Model.fieldName = (Model.Name "targetFile"),+        Model.fieldTerm = Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.DocumentationProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "severity"),+          Model.fieldTerm = (Typed.unTypedTerm severity)},+        Model.Field {+          Model.fieldName = (Model.Name "exemptDeprecated"),+          Model.fieldTerm = (Typed.unTypedTerm exemptDeprecated)}]}))++-- | DSL name token for hydra.build.format.DocumentationProfile+documentationProfileDocumentationProfile :: Typed.TypedName Format.DocumentationProfile+documentationProfileDocumentationProfile = Typed.TypedName (Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.DocumentationProfile"),+        Model.projectionFieldName = (Model.Name "exemptDeprecated")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.DocumentationProfile"),+        Model.projectionFieldName = (Model.Name "severity")})),+      Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.DocumentationProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "severity"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.DocumentationProfile"),+              Model.projectionFieldName = (Model.Name "severity")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "exemptDeprecated"),+          Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.DocumentationProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "severity"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "exemptDeprecated"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.DocumentationProfile"),+              Model.projectionFieldName = (Model.Name "exemptDeprecated")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.Generation"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "generatorId"),+          Model.fieldTerm = (Typed.unTypedTerm generatorId)},+        Model.Field {+          Model.fieldName = (Model.Name "mode"),+          Model.fieldTerm = (Typed.unTypedTerm mode)},+        Model.Field {+          Model.fieldName = (Model.Name "host"),+          Model.fieldTerm = (Typed.unTypedTerm host)},+        Model.Field {+          Model.fieldName = (Model.Name "hydraVersion"),+          Model.fieldTerm = (Typed.unTypedTerm hydraVersion)},+        Model.Field {+          Model.fieldName = (Model.Name "revision"),+          Model.fieldTerm = (Typed.unTypedTerm revision)},+        Model.Field {+          Model.fieldName = (Model.Name "timestamp"),+          Model.fieldTerm = (Typed.unTypedTerm timestamp)}]}))++-- | DSL name token for hydra.build.format.Generation+generationGeneration :: Typed.TypedName Format.Generation+generationGeneration = Typed.TypedName (Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+        Model.projectionFieldName = (Model.Name "generatorId")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+        Model.projectionFieldName = (Model.Name "host")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+        Model.projectionFieldName = (Model.Name "hydraVersion")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+        Model.projectionFieldName = (Model.Name "mode")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.format.GenerationMode+generationModeGenerationMode :: Typed.TypedName Format.GenerationMode+generationModeGenerationMode = Typed.TypedName (Model.Name "hydra.build.format.GenerationMode")++-- | DSL injection for the published variant of hydra.build.format.GenerationMode+generationModePublished :: Typed.TypedTerm Format.GenerationMode+generationModePublished =+    Typed.TypedTerm (Model.TermInject (Model.Injection {+      Model.injectionTypeName = (Model.Name "hydra.build.format.GenerationMode"),+      Model.injectionField = Model.Field {+        Model.fieldName = (Model.Name "published"),+        Model.fieldTerm = Model.TermUnit}}))++-- | DSL injection for the shim variant of hydra.build.format.GenerationMode+generationModeShim :: Typed.TypedTerm Format.GenerationMode+generationModeShim =+    Typed.TypedTerm (Model.TermInject (Model.Injection {+      Model.injectionTypeName = (Model.Name "hydra.build.format.GenerationMode"),+      Model.injectionField = Model.Field {+        Model.fieldName = (Model.Name "shim"),+        Model.fieldTerm = Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+        Model.projectionFieldName = (Model.Name "revision")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+        Model.projectionFieldName = (Model.Name "timestamp")})),+      Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.Generation"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "generatorId"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "mode"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+              Model.projectionFieldName = (Model.Name "mode")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "host"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+              Model.projectionFieldName = (Model.Name "host")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "hydraVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+              Model.projectionFieldName = (Model.Name "hydraVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "revision"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+              Model.projectionFieldName = (Model.Name "revision")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "timestamp"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+              Model.projectionFieldName = (Model.Name "timestamp")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.Generation"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "generatorId"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+              Model.projectionFieldName = (Model.Name "generatorId")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "mode"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+              Model.projectionFieldName = (Model.Name "mode")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "host"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "hydraVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+              Model.projectionFieldName = (Model.Name "hydraVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "revision"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+              Model.projectionFieldName = (Model.Name "revision")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "timestamp"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+              Model.projectionFieldName = (Model.Name "timestamp")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.Generation"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "generatorId"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+              Model.projectionFieldName = (Model.Name "generatorId")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "mode"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+              Model.projectionFieldName = (Model.Name "mode")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "host"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+              Model.projectionFieldName = (Model.Name "host")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "hydraVersion"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "revision"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+              Model.projectionFieldName = (Model.Name "revision")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "timestamp"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+              Model.projectionFieldName = (Model.Name "timestamp")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.Generation"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "generatorId"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+              Model.projectionFieldName = (Model.Name "generatorId")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "mode"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "host"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+              Model.projectionFieldName = (Model.Name "host")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "hydraVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+              Model.projectionFieldName = (Model.Name "hydraVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "revision"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+              Model.projectionFieldName = (Model.Name "revision")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "timestamp"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+              Model.projectionFieldName = (Model.Name "timestamp")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.Generation"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "generatorId"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+              Model.projectionFieldName = (Model.Name "generatorId")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "mode"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+              Model.projectionFieldName = (Model.Name "mode")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "host"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+              Model.projectionFieldName = (Model.Name "host")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "hydraVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+              Model.projectionFieldName = (Model.Name "hydraVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "revision"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "timestamp"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+              Model.projectionFieldName = (Model.Name "timestamp")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.Generation"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "generatorId"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+              Model.projectionFieldName = (Model.Name "generatorId")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "mode"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+              Model.projectionFieldName = (Model.Name "mode")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "host"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+              Model.projectionFieldName = (Model.Name "host")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "hydraVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+              Model.projectionFieldName = (Model.Name "hydraVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "revision"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.Generation"),+              Model.projectionFieldName = (Model.Name "revision")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "timestamp"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL name token for hydra.build.format.HostOverride+hostOverrideHostOverride :: Typed.TypedName Format.HostOverride+hostOverrideHostOverride = Typed.TypedName (Model.Name "hydra.build.format.HostOverride")++-- | DSL injection for the local variant of hydra.build.format.HostOverride+hostOverrideLocal :: Typed.TypedTerm Format.HostOverride+hostOverrideLocal =+    Typed.TypedTerm (Model.TermInject (Model.Injection {+      Model.injectionTypeName = (Model.Name "hydra.build.format.HostOverride"),+      Model.injectionField = Model.Field {+        Model.fieldName = (Model.Name "local"),+        Model.fieldTerm = Model.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 (Model.TermInject (Model.Injection {+      Model.injectionTypeName = (Model.Name "hydra.build.format.HostOverride"),+      Model.injectionField = Model.Field {+        Model.fieldName = (Model.Name "version"),+        Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.InputDigest"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "digestFormatVersion"),+          Model.fieldTerm = (Typed.unTypedTerm digestFormatVersion)},+        Model.Field {+          Model.fieldName = (Model.Name "moduleFormatVersion"),+          Model.fieldTerm = (Typed.unTypedTerm moduleFormatVersion)},+        Model.Field {+          Model.fieldName = (Model.Name "selfHash"),+          Model.fieldTerm = (Typed.unTypedTerm selfHash)},+        Model.Field {+          Model.fieldName = (Model.Name "dependencyHashes"),+          Model.fieldTerm = (Typed.unTypedTerm dependencyHashes)},+        Model.Field {+          Model.fieldName = (Model.Name "moduleHashes"),+          Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"),+        Model.projectionFieldName = (Model.Name "dependencyHashes")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"),+        Model.projectionFieldName = (Model.Name "digestFormatVersion")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.format.InputDigest+inputDigestInputDigest :: Typed.TypedName Format.InputDigest+inputDigestInputDigest = Typed.TypedName (Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"),+        Model.projectionFieldName = (Model.Name "moduleFormatVersion")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"),+        Model.projectionFieldName = (Model.Name "moduleHashes")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"),+        Model.projectionFieldName = (Model.Name "selfHash")})),+      Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.InputDigest"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "digestFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"),+              Model.projectionFieldName = (Model.Name "digestFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "moduleFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"),+              Model.projectionFieldName = (Model.Name "moduleFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "selfHash"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"),+              Model.projectionFieldName = (Model.Name "selfHash")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "dependencyHashes"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "moduleHashes"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"),+              Model.projectionFieldName = (Model.Name "moduleHashes")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.InputDigest"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "digestFormatVersion"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "moduleFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"),+              Model.projectionFieldName = (Model.Name "moduleFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "selfHash"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"),+              Model.projectionFieldName = (Model.Name "selfHash")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "dependencyHashes"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"),+              Model.projectionFieldName = (Model.Name "dependencyHashes")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "moduleHashes"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"),+              Model.projectionFieldName = (Model.Name "moduleHashes")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.InputDigest"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "digestFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"),+              Model.projectionFieldName = (Model.Name "digestFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "moduleFormatVersion"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "selfHash"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"),+              Model.projectionFieldName = (Model.Name "selfHash")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "dependencyHashes"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"),+              Model.projectionFieldName = (Model.Name "dependencyHashes")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "moduleHashes"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"),+              Model.projectionFieldName = (Model.Name "moduleHashes")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.InputDigest"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "digestFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"),+              Model.projectionFieldName = (Model.Name "digestFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "moduleFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"),+              Model.projectionFieldName = (Model.Name "moduleFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "selfHash"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"),+              Model.projectionFieldName = (Model.Name "selfHash")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "dependencyHashes"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"),+              Model.projectionFieldName = (Model.Name "dependencyHashes")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "moduleHashes"),+          Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.InputDigest"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "digestFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"),+              Model.projectionFieldName = (Model.Name "digestFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "moduleFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"),+              Model.projectionFieldName = (Model.Name "moduleFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "selfHash"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "dependencyHashes"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"),+              Model.projectionFieldName = (Model.Name "dependencyHashes")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "moduleHashes"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.InputDigest"),+              Model.projectionFieldName = (Model.Name "moduleHashes")})),+            Model.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 (Model.TermWrap (Model.WrappedTerm {+      Model.wrappedTermTypeName = (Model.Name "hydra.build.format.LanguageName"),+      Model.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.format.LanguageName+languageNameLanguageName :: Typed.TypedName Format.LanguageName+languageNameLanguageName = Typed.TypedName (Model.Name "hydra.build.format.LanguageName")++-- | DSL constructor for hydra.build.format.LanguageProfile+languageProfile :: Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm Format.LanguageProfile+languageProfile name coderPackage family =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.LanguageProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "name"),+          Model.fieldTerm = (Typed.unTypedTerm name)},+        Model.Field {+          Model.fieldName = (Model.Name "coderPackage"),+          Model.fieldTerm = (Typed.unTypedTerm coderPackage)},+        Model.Field {+          Model.fieldName = (Model.Name "family"),+          Model.fieldTerm = (Typed.unTypedTerm family)}]}))++-- | DSL accessor for the coderPackage field of hydra.build.format.LanguageProfile+languageProfileCoderPackage :: Typed.TypedTerm Format.LanguageProfile -> Typed.TypedTerm String+languageProfileCoderPackage x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.LanguageProfile"),+        Model.projectionFieldName = (Model.Name "coderPackage")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the family field of hydra.build.format.LanguageProfile+languageProfileFamily :: Typed.TypedTerm Format.LanguageProfile -> Typed.TypedTerm String+languageProfileFamily x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.LanguageProfile"),+        Model.projectionFieldName = (Model.Name "family")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.format.LanguageProfile+languageProfileLanguageProfile :: Typed.TypedName Format.LanguageProfile+languageProfileLanguageProfile = Typed.TypedName (Model.Name "hydra.build.format.LanguageProfile")++-- | DSL accessor for the name field of hydra.build.format.LanguageProfile+languageProfileName :: Typed.TypedTerm Format.LanguageProfile -> Typed.TypedTerm String+languageProfileName x =+    Typed.TypedTerm (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.LanguageProfile"),+        Model.projectionFieldName = (Model.Name "name")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the coderPackage field of hydra.build.format.LanguageProfile+languageProfileWithCoderPackage :: Typed.TypedTerm Format.LanguageProfile -> Typed.TypedTerm String -> Typed.TypedTerm Format.LanguageProfile+languageProfileWithCoderPackage original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.LanguageProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "name"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.LanguageProfile"),+              Model.projectionFieldName = (Model.Name "name")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "coderPackage"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "family"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.LanguageProfile"),+              Model.projectionFieldName = (Model.Name "family")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the family field of hydra.build.format.LanguageProfile+languageProfileWithFamily :: Typed.TypedTerm Format.LanguageProfile -> Typed.TypedTerm String -> Typed.TypedTerm Format.LanguageProfile+languageProfileWithFamily original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.LanguageProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "name"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.LanguageProfile"),+              Model.projectionFieldName = (Model.Name "name")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "coderPackage"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.LanguageProfile"),+              Model.projectionFieldName = (Model.Name "coderPackage")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "family"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the name field of hydra.build.format.LanguageProfile+languageProfileWithName :: Typed.TypedTerm Format.LanguageProfile -> Typed.TypedTerm String -> Typed.TypedTerm Format.LanguageProfile+languageProfileWithName original newVal =+    Typed.TypedTerm (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.LanguageProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "name"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "coderPackage"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.LanguageProfile"),+              Model.projectionFieldName = (Model.Name "coderPackage")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "family"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.LanguageProfile"),+              Model.projectionFieldName = (Model.Name "family")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | 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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.ModuleValidationProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "definitions"),+          Model.fieldTerm = (Typed.unTypedTerm definitions)},+        Model.Field {+          Model.fieldName = (Model.Name "nameConvention"),+          Model.fieldTerm = (Typed.unTypedTerm nameConvention)},+        Model.Field {+          Model.fieldName = (Model.Name "conflictingVariantName"),+          Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.ModuleValidationProfile"),+        Model.projectionFieldName = (Model.Name "conflictingVariantName")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.ModuleValidationProfile"),+        Model.projectionFieldName = (Model.Name "definitions")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.format.ModuleValidationProfile+moduleValidationProfileModuleValidationProfile :: Typed.TypedName Format.ModuleValidationProfile+moduleValidationProfileModuleValidationProfile = Typed.TypedName (Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.ModuleValidationProfile"),+        Model.projectionFieldName = (Model.Name "nameConvention")})),+      Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.ModuleValidationProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "definitions"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.ModuleValidationProfile"),+              Model.projectionFieldName = (Model.Name "definitions")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "nameConvention"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.ModuleValidationProfile"),+              Model.projectionFieldName = (Model.Name "nameConvention")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "conflictingVariantName"),+          Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.ModuleValidationProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "definitions"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "nameConvention"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.ModuleValidationProfile"),+              Model.projectionFieldName = (Model.Name "nameConvention")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "conflictingVariantName"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.ModuleValidationProfile"),+              Model.projectionFieldName = (Model.Name "conflictingVariantName")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.ModuleValidationProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "definitions"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.ModuleValidationProfile"),+              Model.projectionFieldName = (Model.Name "definitions")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "nameConvention"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "conflictingVariantName"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.ModuleValidationProfile"),+              Model.projectionFieldName = (Model.Name "conflictingVariantName")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.OutputDigest"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "digestFormatVersion"),+          Model.fieldTerm = (Typed.unTypedTerm digestFormatVersion)},+        Model.Field {+          Model.fieldName = (Model.Name "moduleFormatVersion"),+          Model.fieldTerm = (Typed.unTypedTerm moduleFormatVersion)},+        Model.Field {+          Model.fieldName = (Model.Name "generator"),+          Model.fieldTerm = (Typed.unTypedTerm generator)},+        Model.Field {+          Model.fieldName = (Model.Name "generation"),+          Model.fieldTerm = (Typed.unTypedTerm generation)},+        Model.Field {+          Model.fieldName = (Model.Name "selfHash"),+          Model.fieldTerm = (Typed.unTypedTerm selfHash)},+        Model.Field {+          Model.fieldName = (Model.Name "dependencyHashes"),+          Model.fieldTerm = (Typed.unTypedTerm dependencyHashes)},+        Model.Field {+          Model.fieldName = (Model.Name "inputs"),+          Model.fieldTerm = (Typed.unTypedTerm inputs)},+        Model.Field {+          Model.fieldName = (Model.Name "outputs"),+          Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+        Model.projectionFieldName = (Model.Name "dependencyHashes")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+        Model.projectionFieldName = (Model.Name "digestFormatVersion")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+        Model.projectionFieldName = (Model.Name "generation")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+        Model.projectionFieldName = (Model.Name "generator")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+        Model.projectionFieldName = (Model.Name "inputs")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+        Model.projectionFieldName = (Model.Name "moduleFormatVersion")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.format.OutputDigest+outputDigestOutputDigest :: Typed.TypedName Format.OutputDigest+outputDigestOutputDigest = Typed.TypedName (Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+        Model.projectionFieldName = (Model.Name "outputs")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+        Model.projectionFieldName = (Model.Name "selfHash")})),+      Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.OutputDigest"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "digestFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "digestFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "moduleFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "moduleFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "generator"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "generator")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "generation"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "generation")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "selfHash"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "selfHash")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "dependencyHashes"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "inputs"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "inputs")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "outputs"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "outputs")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.OutputDigest"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "digestFormatVersion"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "moduleFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "moduleFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "generator"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "generator")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "generation"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "generation")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "selfHash"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "selfHash")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "dependencyHashes"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "dependencyHashes")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "inputs"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "inputs")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "outputs"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "outputs")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.OutputDigest"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "digestFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "digestFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "moduleFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "moduleFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "generator"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "generator")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "generation"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "selfHash"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "selfHash")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "dependencyHashes"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "dependencyHashes")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "inputs"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "inputs")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "outputs"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "outputs")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.OutputDigest"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "digestFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "digestFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "moduleFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "moduleFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "generator"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "generation"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "generation")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "selfHash"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "selfHash")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "dependencyHashes"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "dependencyHashes")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "inputs"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "inputs")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "outputs"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "outputs")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.OutputDigest"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "digestFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "digestFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "moduleFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "moduleFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "generator"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "generator")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "generation"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "generation")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "selfHash"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "selfHash")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "dependencyHashes"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "dependencyHashes")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "inputs"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "outputs"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "outputs")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.OutputDigest"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "digestFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "digestFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "moduleFormatVersion"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "generator"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "generator")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "generation"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "generation")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "selfHash"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "selfHash")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "dependencyHashes"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "dependencyHashes")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "inputs"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "inputs")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "outputs"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "outputs")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.OutputDigest"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "digestFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "digestFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "moduleFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "moduleFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "generator"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "generator")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "generation"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "generation")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "selfHash"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "selfHash")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "dependencyHashes"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "dependencyHashes")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "inputs"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "inputs")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "outputs"),+          Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.OutputDigest"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "digestFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "digestFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "moduleFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "moduleFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "generator"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "generator")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "generation"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "generation")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "selfHash"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "dependencyHashes"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "dependencyHashes")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "inputs"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "inputs")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "outputs"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.OutputDigest"),+              Model.projectionFieldName = (Model.Name "outputs")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "packageFormatVersion"),+          Model.fieldTerm = (Typed.unTypedTerm packageFormatVersion)},+        Model.Field {+          Model.fieldName = (Model.Name "name"),+          Model.fieldTerm = (Typed.unTypedTerm name)},+        Model.Field {+          Model.fieldName = (Model.Name "description"),+          Model.fieldTerm = (Typed.unTypedTerm description)},+        Model.Field {+          Model.fieldName = (Model.Name "sourceLanguage"),+          Model.fieldTerm = (Typed.unTypedTerm sourceLanguage)},+        Model.Field {+          Model.fieldName = (Model.Name "targetLanguages"),+          Model.fieldTerm = (Typed.unTypedTerm targetLanguages)},+        Model.Field {+          Model.fieldName = (Model.Name "dependencies"),+          Model.fieldTerm = (Typed.unTypedTerm dependencies)},+        Model.Field {+          Model.fieldName = (Model.Name "validation"),+          Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+        Model.projectionFieldName = (Model.Name "dependencies")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+        Model.projectionFieldName = (Model.Name "description")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+        Model.projectionFieldName = (Model.Name "name")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.format.PackageDescriptor+packageDescriptorPackageDescriptor :: Typed.TypedName Format.PackageDescriptor+packageDescriptorPackageDescriptor = Typed.TypedName (Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+        Model.projectionFieldName = (Model.Name "packageFormatVersion")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+        Model.projectionFieldName = (Model.Name "sourceLanguage")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+        Model.projectionFieldName = (Model.Name "targetLanguages")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+        Model.projectionFieldName = (Model.Name "validation")})),+      Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "packageFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "packageFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "name"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "name")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "description"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "description")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "sourceLanguage"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "sourceLanguage")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "targetLanguages"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "targetLanguages")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "dependencies"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "validation"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "validation")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "packageFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "packageFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "name"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "name")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "description"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "sourceLanguage"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "sourceLanguage")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "targetLanguages"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "targetLanguages")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "dependencies"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "dependencies")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "validation"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "validation")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "packageFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "packageFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "name"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "description"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "description")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "sourceLanguage"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "sourceLanguage")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "targetLanguages"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "targetLanguages")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "dependencies"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "dependencies")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "validation"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "validation")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "packageFormatVersion"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "name"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "name")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "description"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "description")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "sourceLanguage"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "sourceLanguage")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "targetLanguages"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "targetLanguages")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "dependencies"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "dependencies")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "validation"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "validation")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "packageFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "packageFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "name"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "name")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "description"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "description")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "sourceLanguage"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "targetLanguages"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "targetLanguages")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "dependencies"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "dependencies")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "validation"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "validation")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "packageFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "packageFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "name"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "name")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "description"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "description")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "sourceLanguage"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "sourceLanguage")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "targetLanguages"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "dependencies"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "dependencies")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "validation"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "validation")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "packageFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "packageFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "name"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "name")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "description"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "description")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "sourceLanguage"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "sourceLanguage")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "targetLanguages"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "targetLanguages")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "dependencies"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageDescriptor"),+              Model.projectionFieldName = (Model.Name "dependencies")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "validation"),+          Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.PackageManifest"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "manifestFormatVersion"),+          Model.fieldTerm = (Typed.unTypedTerm manifestFormatVersion)},+        Model.Field {+          Model.fieldName = (Model.Name "moduleFormatVersion"),+          Model.fieldTerm = (Typed.unTypedTerm moduleFormatVersion)},+        Model.Field {+          Model.fieldName = (Model.Name "package"),+          Model.fieldTerm = (Typed.unTypedTerm package)},+        Model.Field {+          Model.fieldName = (Model.Name "mainModules"),+          Model.fieldTerm = (Typed.unTypedTerm mainModules)},+        Model.Field {+          Model.fieldName = (Model.Name "testModules"),+          Model.fieldTerm = (Typed.unTypedTerm testModules)},+        Model.Field {+          Model.fieldName = (Model.Name "mainDslModules"),+          Model.fieldTerm = (Typed.unTypedTerm mainDslModules)},+        Model.Field {+          Model.fieldName = (Model.Name "mainEncodingModules"),+          Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+        Model.projectionFieldName = (Model.Name "mainDslModules")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+        Model.projectionFieldName = (Model.Name "mainEncodingModules")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+        Model.projectionFieldName = (Model.Name "mainModules")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+        Model.projectionFieldName = (Model.Name "manifestFormatVersion")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+        Model.projectionFieldName = (Model.Name "moduleFormatVersion")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+        Model.projectionFieldName = (Model.Name "package")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.format.PackageManifest+packageManifestPackageManifest :: Typed.TypedName Format.PackageManifest+packageManifestPackageManifest = Typed.TypedName (Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+        Model.projectionFieldName = (Model.Name "testModules")})),+      Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.PackageManifest"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "manifestFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "manifestFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "moduleFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "moduleFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "package"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "package")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "mainModules"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "mainModules")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "testModules"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "testModules")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "mainDslModules"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "mainEncodingModules"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "mainEncodingModules")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.PackageManifest"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "manifestFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "manifestFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "moduleFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "moduleFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "package"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "package")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "mainModules"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "mainModules")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "testModules"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "testModules")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "mainDslModules"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "mainDslModules")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "mainEncodingModules"),+          Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.PackageManifest"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "manifestFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "manifestFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "moduleFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "moduleFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "package"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "package")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "mainModules"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "testModules"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "testModules")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "mainDslModules"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "mainDslModules")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "mainEncodingModules"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "mainEncodingModules")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.PackageManifest"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "manifestFormatVersion"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "moduleFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "moduleFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "package"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "package")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "mainModules"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "mainModules")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "testModules"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "testModules")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "mainDslModules"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "mainDslModules")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "mainEncodingModules"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "mainEncodingModules")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.PackageManifest"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "manifestFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "manifestFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "moduleFormatVersion"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "package"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "package")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "mainModules"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "mainModules")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "testModules"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "testModules")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "mainDslModules"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "mainDslModules")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "mainEncodingModules"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "mainEncodingModules")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.PackageManifest"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "manifestFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "manifestFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "moduleFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "moduleFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "package"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "mainModules"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "mainModules")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "testModules"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "testModules")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "mainDslModules"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "mainDslModules")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "mainEncodingModules"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "mainEncodingModules")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.PackageManifest"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "manifestFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "manifestFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "moduleFormatVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "moduleFormatVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "package"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "package")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "mainModules"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "mainModules")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "testModules"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "mainDslModules"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "mainDslModules")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "mainEncodingModules"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageManifest"),+              Model.projectionFieldName = (Model.Name "mainEncodingModules")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "package"),+          Model.fieldTerm = (Typed.unTypedTerm package)},+        Model.Field {+          Model.fieldName = (Model.Name "module"),+          Model.fieldTerm = (Typed.unTypedTerm module_)},+        Model.Field {+          Model.fieldName = (Model.Name "type"),+          Model.fieldTerm = (Typed.unTypedTerm type_)},+        Model.Field {+          Model.fieldName = (Model.Name "term"),+          Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"),+        Model.projectionFieldName = (Model.Name "module")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"),+        Model.projectionFieldName = (Model.Name "package")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.format.PackageValidationConfiguration+packageValidationConfigurationPackageValidationConfiguration :: Typed.TypedName Format.PackageValidationConfiguration+packageValidationConfigurationPackageValidationConfiguration =+    Typed.TypedName (Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"),+        Model.projectionFieldName = (Model.Name "term")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"),+        Model.projectionFieldName = (Model.Name "type")})),+      Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "package"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"),+              Model.projectionFieldName = (Model.Name "package")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "module"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "type"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"),+              Model.projectionFieldName = (Model.Name "type")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "term"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"),+              Model.projectionFieldName = (Model.Name "term")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "package"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "module"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"),+              Model.projectionFieldName = (Model.Name "module")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "type"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"),+              Model.projectionFieldName = (Model.Name "type")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "term"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"),+              Model.projectionFieldName = (Model.Name "term")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "package"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"),+              Model.projectionFieldName = (Model.Name "package")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "module"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"),+              Model.projectionFieldName = (Model.Name "module")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "type"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"),+              Model.projectionFieldName = (Model.Name "type")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "term"),+          Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "package"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"),+              Model.projectionFieldName = (Model.Name "package")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "module"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"),+              Model.projectionFieldName = (Model.Name "module")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "type"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "term"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationConfiguration"),+              Model.projectionFieldName = (Model.Name "term")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.PackageValidationProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "conflictingModuleName"),+          Model.fieldTerm = (Typed.unTypedTerm conflictingModuleName)},+        Model.Field {+          Model.fieldName = (Model.Name "duplicateModuleName"),+          Model.fieldTerm = (Typed.unTypedTerm duplicateModuleName)},+        Model.Field {+          Model.fieldName = (Model.Name "nameConvention"),+          Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationProfile"),+        Model.projectionFieldName = (Model.Name "conflictingModuleName")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationProfile"),+        Model.projectionFieldName = (Model.Name "duplicateModuleName")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationProfile"),+        Model.projectionFieldName = (Model.Name "nameConvention")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.format.PackageValidationProfile+packageValidationProfilePackageValidationProfile :: Typed.TypedName Format.PackageValidationProfile+packageValidationProfilePackageValidationProfile =+    Typed.TypedName (Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.PackageValidationProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "conflictingModuleName"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "duplicateModuleName"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationProfile"),+              Model.projectionFieldName = (Model.Name "duplicateModuleName")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "nameConvention"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationProfile"),+              Model.projectionFieldName = (Model.Name "nameConvention")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.PackageValidationProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "conflictingModuleName"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationProfile"),+              Model.projectionFieldName = (Model.Name "conflictingModuleName")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "duplicateModuleName"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "nameConvention"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationProfile"),+              Model.projectionFieldName = (Model.Name "nameConvention")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.PackageValidationProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "conflictingModuleName"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationProfile"),+              Model.projectionFieldName = (Model.Name "conflictingModuleName")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "duplicateModuleName"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.PackageValidationProfile"),+              Model.projectionFieldName = (Model.Name "duplicateModuleName")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "nameConvention"),+          Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "currentVersion"),+          Model.fieldTerm = (Typed.unTypedTerm currentVersion)},+        Model.Field {+          Model.fieldName = (Model.Name "hostVersion"),+          Model.fieldTerm = (Typed.unTypedTerm hostVersion)},+        Model.Field {+          Model.fieldName = (Model.Name "hostOverrides"),+          Model.fieldTerm = (Typed.unTypedTerm hostOverrides)},+        Model.Field {+          Model.fieldName = (Model.Name "group"),+          Model.fieldTerm = (Typed.unTypedTerm group)},+        Model.Field {+          Model.fieldName = (Model.Name "author"),+          Model.fieldTerm = (Typed.unTypedTerm author)},+        Model.Field {+          Model.fieldName = (Model.Name "url"),+          Model.fieldTerm = (Typed.unTypedTerm url)},+        Model.Field {+          Model.fieldName = (Model.Name "license"),+          Model.fieldTerm = (Typed.unTypedTerm license)},+        Model.Field {+          Model.fieldName = (Model.Name "packages"),+          Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+        Model.projectionFieldName = (Model.Name "author")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+        Model.projectionFieldName = (Model.Name "currentVersion")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+        Model.projectionFieldName = (Model.Name "group")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+        Model.projectionFieldName = (Model.Name "hostOverrides")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+        Model.projectionFieldName = (Model.Name "hostVersion")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+        Model.projectionFieldName = (Model.Name "license")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+        Model.projectionFieldName = (Model.Name "packages")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.format.RepositoryDescriptor+repositoryDescriptorRepositoryDescriptor :: Typed.TypedName Format.RepositoryDescriptor+repositoryDescriptorRepositoryDescriptor = Typed.TypedName (Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+        Model.projectionFieldName = (Model.Name "url")})),+      Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "currentVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "currentVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "hostVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "hostVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "hostOverrides"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "hostOverrides")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "group"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "group")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "author"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "url"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "url")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "license"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "license")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "packages"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "packages")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "currentVersion"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "hostVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "hostVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "hostOverrides"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "hostOverrides")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "group"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "group")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "author"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "author")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "url"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "url")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "license"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "license")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "packages"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "packages")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "currentVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "currentVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "hostVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "hostVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "hostOverrides"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "hostOverrides")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "group"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "author"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "author")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "url"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "url")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "license"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "license")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "packages"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "packages")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "currentVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "currentVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "hostVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "hostVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "hostOverrides"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "group"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "group")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "author"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "author")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "url"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "url")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "license"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "license")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "packages"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "packages")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "currentVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "currentVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "hostVersion"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "hostOverrides"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "hostOverrides")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "group"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "group")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "author"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "author")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "url"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "url")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "license"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "license")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "packages"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "packages")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "currentVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "currentVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "hostVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "hostVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "hostOverrides"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "hostOverrides")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "group"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "group")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "author"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "author")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "url"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "url")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "license"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "packages"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "packages")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "currentVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "currentVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "hostVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "hostVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "hostOverrides"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "hostOverrides")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "group"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "group")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "author"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "author")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "url"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "url")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "license"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "license")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "packages"),+          Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "currentVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "currentVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "hostVersion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "hostVersion")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "hostOverrides"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "hostOverrides")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "group"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "group")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "author"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "author")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "url"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "license"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "license")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "packages"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.RepositoryDescriptor"),+              Model.projectionFieldName = (Model.Name "packages")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL injection for the error variant of hydra.build.format.Severity+severityError :: Typed.TypedTerm Format.Severity+severityError =+    Typed.TypedTerm (Model.TermInject (Model.Injection {+      Model.injectionTypeName = (Model.Name "hydra.build.format.Severity"),+      Model.injectionField = Model.Field {+        Model.fieldName = (Model.Name "error"),+        Model.fieldTerm = Model.TermUnit}}))++-- | DSL name token for hydra.build.format.Severity+severitySeverity :: Typed.TypedName Format.Severity+severitySeverity = Typed.TypedName (Model.Name "hydra.build.format.Severity")++-- | DSL injection for the warning variant of hydra.build.format.Severity+severityWarning :: Typed.TypedTerm Format.Severity+severityWarning =+    Typed.TypedTerm (Model.TermInject (Model.Injection {+      Model.injectionTypeName = (Model.Name "hydra.build.format.Severity"),+      Model.injectionField = Model.Field {+        Model.fieldName = (Model.Name "warning"),+        Model.fieldTerm = Model.TermUnit}}))++-- | DSL constructor for the hydra.build.format.Sha256Hash wrapper+sha256Hash :: Typed.TypedTerm String -> Typed.TypedTerm Format.Sha256Hash+sha256Hash x =+    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {+      Model.wrappedTermTypeName = (Model.Name "hydra.build.format.Sha256Hash"),+      Model.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.format.Sha256Hash+sha256HashSha256Hash :: Typed.TypedName Format.Sha256Hash+sha256HashSha256Hash = Typed.TypedName (Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.TermValidationProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "duplicateBinding"),+          Model.fieldTerm = (Typed.unTypedTerm duplicateBinding)},+        Model.Field {+          Model.fieldName = (Model.Name "emptyTermAnnotation"),+          Model.fieldTerm = (Typed.unTypedTerm emptyTermAnnotation)},+        Model.Field {+          Model.fieldName = (Model.Name "undefinedVariable"),+          Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.TermValidationProfile"),+        Model.projectionFieldName = (Model.Name "duplicateBinding")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.TermValidationProfile"),+        Model.projectionFieldName = (Model.Name "emptyTermAnnotation")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.format.TermValidationProfile+termValidationProfileTermValidationProfile :: Typed.TypedName Format.TermValidationProfile+termValidationProfileTermValidationProfile = Typed.TypedName (Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.TermValidationProfile"),+        Model.projectionFieldName = (Model.Name "undefinedVariable")})),+      Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.TermValidationProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "duplicateBinding"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "emptyTermAnnotation"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.TermValidationProfile"),+              Model.projectionFieldName = (Model.Name "emptyTermAnnotation")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "undefinedVariable"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.TermValidationProfile"),+              Model.projectionFieldName = (Model.Name "undefinedVariable")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.TermValidationProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "duplicateBinding"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.TermValidationProfile"),+              Model.projectionFieldName = (Model.Name "duplicateBinding")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "emptyTermAnnotation"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "undefinedVariable"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.TermValidationProfile"),+              Model.projectionFieldName = (Model.Name "undefinedVariable")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.TermValidationProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "duplicateBinding"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.TermValidationProfile"),+              Model.projectionFieldName = (Model.Name "duplicateBinding")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "emptyTermAnnotation"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.TermValidationProfile"),+              Model.projectionFieldName = (Model.Name "emptyTermAnnotation")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "undefinedVariable"),+          Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.TypeValidationProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "emptyAnnotation"),+          Model.fieldTerm = (Typed.unTypedTerm emptyAnnotation)},+        Model.Field {+          Model.fieldName = (Model.Name "duplicateField"),+          Model.fieldTerm = (Typed.unTypedTerm duplicateField)},+        Model.Field {+          Model.fieldName = (Model.Name "singleVariantUnion"),+          Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.TypeValidationProfile"),+        Model.projectionFieldName = (Model.Name "duplicateField")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.TypeValidationProfile"),+        Model.projectionFieldName = (Model.Name "emptyAnnotation")})),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermProject (Model.Projection {+        Model.projectionTypeName = (Model.Name "hydra.build.format.TypeValidationProfile"),+        Model.projectionFieldName = (Model.Name "singleVariantUnion")})),+      Model.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.format.TypeValidationProfile+typeValidationProfileTypeValidationProfile :: Typed.TypedName Format.TypeValidationProfile+typeValidationProfileTypeValidationProfile = Typed.TypedName (Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.TypeValidationProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "emptyAnnotation"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.TypeValidationProfile"),+              Model.projectionFieldName = (Model.Name "emptyAnnotation")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "duplicateField"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "singleVariantUnion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.TypeValidationProfile"),+              Model.projectionFieldName = (Model.Name "singleVariantUnion")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.TypeValidationProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "emptyAnnotation"),+          Model.fieldTerm = (Typed.unTypedTerm newVal)},+        Model.Field {+          Model.fieldName = (Model.Name "duplicateField"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.TypeValidationProfile"),+              Model.projectionFieldName = (Model.Name "duplicateField")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "singleVariantUnion"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.TypeValidationProfile"),+              Model.projectionFieldName = (Model.Name "singleVariantUnion")})),+            Model.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 (Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.format.TypeValidationProfile"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "emptyAnnotation"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.TypeValidationProfile"),+              Model.projectionFieldName = (Model.Name "emptyAnnotation")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "duplicateField"),+          Model.fieldTerm = (Model.TermApplication (Model.Application {+            Model.applicationFunction = (Model.TermProject (Model.Projection {+              Model.projectionTypeName = (Model.Name "hydra.build.format.TypeValidationProfile"),+              Model.projectionFieldName = (Model.Name "duplicateField")})),+            Model.applicationArgument = (Typed.unTypedTerm original)}))},+        Model.Field {+          Model.fieldName = (Model.Name "singleVariantUnion"),+          Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.build.format.LanguageName")),+      Model.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 (Model.TermApplication (Model.Application {+      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.build.format.Sha256Hash")),+      Model.applicationArgument = (Typed.unTypedTerm x)}))

@@ -0,0 +1,82 @@+-- Note: this is an automatically generated file. Do not edit.++-- | Term encoders for hydra.build.assembly++module Hydra.Build.Encode.Assembly where++import qualified Hydra.Build.Assembly as Assembly+import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists+import qualified Hydra.Core.Model as Model+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)+import qualified Data.Scientific as Sci+import Data.Void++-- | Encoder for hydra.build.assembly.AssemblyEntry+assemblyEntry :: Assembly.AssemblyEntry -> Model.Term+assemblyEntry x =+    Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.assembly.AssemblyEntry"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "sourceTree"),+          Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Assembly.assemblyEntrySourceTree x))},+        Model.Field {+          Model.fieldName = (Model.Name "destTree"),+          Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Assembly.assemblyEntryDestTree x))},+        Model.Field {+          Model.fieldName = (Model.Name "kind"),+          Model.fieldTerm = (assemblyEntryKind (Assembly.assemblyEntryKind x))},+        Model.Field {+          Model.fieldName = (Model.Name "exclude"),+          Model.fieldTerm = ((\xs -> Model.TermList (Lists.map (\x2 -> Model.TermLiteral (Model.LiteralString x2)) xs)) (Assembly.assemblyEntryExclude x))}]})++-- | Encoder for hydra.build.assembly.AssemblyEntryKind+assemblyEntryKind :: Assembly.AssemblyEntryKind -> Model.Term+assemblyEntryKind x =+    case x of+      Assembly.AssemblyEntryKindMerge -> Model.TermInject (Model.Injection {+        Model.injectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntryKind"),+        Model.injectionField = Model.Field {+          Model.fieldName = (Model.Name "merge"),+          Model.fieldTerm = Model.TermUnit}})+      Assembly.AssemblyEntryKindWipeThenCopy -> Model.TermInject (Model.Injection {+        Model.injectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntryKind"),+        Model.injectionField = Model.Field {+          Model.fieldName = (Model.Name "wipeThenCopy"),+          Model.fieldTerm = Model.TermUnit}})+      Assembly.AssemblyEntryKindSymlinkTree -> Model.TermInject (Model.Injection {+        Model.injectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntryKind"),+        Model.injectionField = Model.Field {+          Model.fieldName = (Model.Name "symlinkTree"),+          Model.fieldTerm = Model.TermUnit}})+      Assembly.AssemblyEntryKindSymlinkDir -> Model.TermInject (Model.Injection {+        Model.injectionTypeName = (Model.Name "hydra.build.assembly.AssemblyEntryKind"),+        Model.injectionField = Model.Field {+          Model.fieldName = (Model.Name "symlinkDir"),+          Model.fieldTerm = Model.TermUnit}})++-- | Encoder for hydra.build.assembly.AssemblyPlan+assemblyPlan :: Assembly.AssemblyPlan -> Model.Term+assemblyPlan x =+    Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.assembly.AssemblyPlan"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "entries"),+          Model.fieldTerm = ((\xs -> Model.TermList (Lists.map assemblyEntry xs)) (Assembly.assemblyPlanEntries x))},+        Model.Field {+          Model.fieldName = (Model.Name "keepPaths"),+          Model.fieldTerm = ((\xs -> Model.TermList (Lists.map keepPathEntry xs)) (Assembly.assemblyPlanKeepPaths x))}]})++-- | Encoder for hydra.build.assembly.KeepPathEntry+keepPathEntry :: Assembly.KeepPathEntry -> Model.Term+keepPathEntry x =+    Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.assembly.KeepPathEntry"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "sourceSetDir"),+          Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Assembly.keepPathEntrySourceSetDir x))},+        Model.Field {+          Model.fieldName = (Model.Name "relPath"),+          Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Assembly.keepPathEntryRelPath x))}]})

@@ -0,0 +1,81 @@+-- Note: this is an automatically generated file. Do not edit.++-- | Term encoders for hydra.build.benchresult++module Hydra.Build.Encode.Benchresult where++import qualified Hydra.Build.Benchresult as Benchresult+import qualified Hydra.Core.Overlay.Haskell.Lib.Lists as Lists+import qualified Hydra.Core.Overlay.Haskell.Lib.Maps as Maps+import qualified Hydra.Core.Overlay.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Core.Model as Model+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)+import qualified Data.Scientific as Sci+import Data.Void++-- | Encoder for hydra.build.benchresult.BenchMetadata+benchMetadata :: Benchresult.BenchMetadata -> Model.Term+benchMetadata x =+    Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.benchresult.BenchMetadata"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "timestamp"),+          Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Benchresult.benchMetadataTimestamp x))},+        Model.Field {+          Model.fieldName = (Model.Name "language"),+          Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Benchresult.benchMetadataLanguage x))},+        Model.Field {+          Model.fieldName = (Model.Name "branch"),+          Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Benchresult.benchMetadataBranch x))},+        Model.Field {+          Model.fieldName = (Model.Name "commit"),+          Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Benchresult.benchMetadataCommit x))},+        Model.Field {+          Model.fieldName = (Model.Name "commitMessage"),+          Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Benchresult.benchMetadataCommitMessage x))}]})++-- | Encoder for hydra.build.benchresult.GenBenchResult+genBenchResult :: Benchresult.GenBenchResult -> Model.Term+genBenchResult x =+    Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.benchresult.GenBenchResult"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "target"),+          Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralString x2)) (Benchresult.genBenchResultTarget x))},+        Model.Field {+          Model.fieldName = (Model.Name "runs"),+          Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralInteger (Model.IntegerValueInt32 x2))) (Benchresult.genBenchResultRuns x))},+        Model.Field {+          Model.fieldName = (Model.Name "hosts"),+          Model.fieldTerm = ((\m -> Model.TermMap (Maps.bimap (\x2 -> Model.TermLiteral (Model.LiteralString x2)) hostResult m)) (Benchresult.genBenchResultHosts x))},+        Model.Field {+          Model.fieldName = (Model.Name "metadata"),+          Model.fieldTerm = ((\opt -> Model.TermOptional (Optionals.map benchMetadata opt)) (Benchresult.genBenchResultMetadata x))}]})++-- | Encoder for hydra.build.benchresult.HostResult+hostResult :: Benchresult.HostResult -> Model.Term+hostResult x =+    Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.benchresult.HostResult"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "setupMs"),+          Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralInteger (Model.IntegerValueInt32 x2))) (Benchresult.hostResultSetupMs x))},+        Model.Field {+          Model.fieldName = (Model.Name "packages"),+          Model.fieldTerm = ((\m -> Model.TermMap (Maps.bimap (\x2 -> Model.TermLiteral (Model.LiteralString x2)) runStats m)) (Benchresult.hostResultPackages x))}]})++-- | Encoder for hydra.build.benchresult.RunStats+runStats :: Benchresult.RunStats -> Model.Term+runStats x =+    Model.TermRecord (Model.Record {+      Model.recordTypeName = (Model.Name "hydra.build.benchresult.RunStats"),+      Model.recordFields = [+        Model.Field {+          Model.fieldName = (Model.Name "runsMs"),+          Model.fieldTerm = ((\xs -> Model.TermList (Lists.map (\x2 -> Model.TermLiteral (Model.LiteralInteger (Model.IntegerValueInt32 x2))) xs)) (Benchresult.runStatsRunsMs x))},+        Model.Field {+          Model.fieldName = (Model.Name "medianMs"),+          Model.fieldTerm = ((\x2 -> Model.TermLiteral (Model.LiteralInteger (Model.IntegerValueInt32 x2))) (Benchresult.runStatsMedianMs x))}]})