hydra-build 0.17.2 → 0.17.3

raw patch · 10 files changed

+5430/−14 lines, 10 filesdep ~hydra-kernelPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: hydra-kernel

API changes (from Hackage documentation)

Files

• hydra-build.cabal +8/−2
• src/main/haskell/Hydra/Build/Format.hs +470/−0
• src/main/haskell/Hydra/Build/Libraries.hs +67/−0
• src/main/haskell/Hydra/Build/ManifestWriter.hs +57/−0
• src/main/haskell/Hydra/Build/Modules.hs +3/−3
• src/main/haskell/Hydra/Build/Reconcile.hs +5/−4
• src/main/haskell/Hydra/Build/Routing.hs +5/−5
• src/main/haskell/Hydra/Decode/Build/Format.hs +415/−0
• src/main/haskell/Hydra/Dsl/Build/Format.hs +3988/−0
• src/main/haskell/Hydra/Encode/Build/Format.hs +412/−0

@@ -5,7 +5,7 @@ -- see: https://github.com/sol/hpack  name:           hydra-build-version:        0.17.2+version:        0.17.3 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@@ -27,9 +27,15 @@  library   exposed-modules:+      Hydra.Build.Format+      Hydra.Build.Libraries+      Hydra.Build.ManifestWriter       Hydra.Build.Modules       Hydra.Build.Reconcile       Hydra.Build.Routing+      Hydra.Decode.Build.Format+      Hydra.Dsl.Build.Format+      Hydra.Encode.Build.Format   other-modules:       Paths_hydra_build   hs-source-dirs:@@ -37,6 +43,6 @@   build-depends:       base >=4.19.0 && <4.22     , containers >=0.6.7 && <0.8-    , hydra-kernel ==0.17.2+    , hydra-kernel ==0.17.3     , scientific >=0.3.7 && <0.4   default-language: Haskell2010

@@ -0,0 +1,470 @@+-- Note: this is an automatically generated file. Do not edit.++-- | Type-level specifications of the JSON formats used by Hydra's build system: the repository descriptor (hydra.json), per-package descriptors (package.json), per-source-set input and output digests (digest.json), generated-source manifests (manifest.json), and per-package validation configuration. Each on-disk file is the canonical JSON encoding of the corresponding type. Overlay build configuration (overlay/<lang>/<pkg>/build.json) is specified separately, by hydra.gradle and hydra.python.pyproject. See https://github.com/CategoricalData/hydra/issues/512++module Hydra.Build.Format where++import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M++-- | Configuration for the definition-name-convention check+data DefinitionNameConventionProfile =+  DefinitionNameConventionProfile {+    -- | How a finding of this check is treated+    definitionNameConventionProfileSeverity :: Severity,+    -- | Whether underscores are permitted in definition names+    definitionNameConventionProfileAllowUnderscores :: Bool}+  deriving (Eq, Ord, Read, Show)++_DefinitionNameConventionProfile = Core.Name "hydra.build.format.DefinitionNameConventionProfile"++_DefinitionNameConventionProfile_severity = Core.Name "severity"++_DefinitionNameConventionProfile_allowUnderscores = Core.Name "allowUnderscores"++-- | Validation rules applying to individual definitions within a module. Absent fields mean the corresponding check is not configured.+data DefinitionValidationProfile =+  DefinitionValidationProfile {+    -- | Configuration for the definition-documentation check+    definitionValidationProfileHasDescription :: (Maybe DocumentationProfile),+    -- | Whether definitions must appear in alphabetical order+    definitionValidationProfileOrdering :: (Maybe Severity),+    -- | Configuration for the definition-name-convention check+    definitionValidationProfileNameConvention :: (Maybe DefinitionNameConventionProfile),+    -- | Whether a definition name may duplicate part of its module name+    definitionValidationProfileNotInModuleName :: (Maybe Severity),+    -- | Whether duplicate definition names within a module are reported+    definitionValidationProfileDuplicateName :: (Maybe Severity)}+  deriving (Eq, Ord, Read, Show)++_DefinitionValidationProfile = Core.Name "hydra.build.format.DefinitionValidationProfile"++_DefinitionValidationProfile_hasDescription = Core.Name "hasDescription"++_DefinitionValidationProfile_ordering = Core.Name "ordering"++_DefinitionValidationProfile_nameConvention = Core.Name "nameConvention"++_DefinitionValidationProfile_notInModuleName = Core.Name "notInModuleName"++_DefinitionValidationProfile_duplicateName = Core.Name "duplicateName"++-- | One file's classification and content hash within a digest+data DigestEntry =+  DigestEntry {+    -- | The kind of artifact recorded+    digestEntryKind :: DigestKind,+    -- | The SHA-256 hash of the file content+    digestEntryHash :: Sha256Hash}+  deriving (Eq, Ord, Read, Show)++_DigestEntry = Core.Name "hydra.build.format.DigestEntry"++_DigestEntry_kind = Core.Name "kind"++_DigestEntry_hash = Core.Name "hash"++-- | The kind of artifact recorded in a digest entry. Lets a single digest mix typed entries without losing the discriminator.+data DigestKind =+  -- | A DSL source file under a package's src/main source tree+  DigestKindDslSource |+  -- | A JSON file under dist/json/+  DigestKindJsonFile |+  -- | A generated source file under dist/<lang>/+  DigestKindTargetFile |+  -- | A hand-written runtime support file copied into the distribution+  DigestKindRuntimeFile |+  -- | Anything else (escape hatch; unknown kinds round-trip as this variant)+  DigestKindOther+  deriving (Eq, Ord, Read, Show)++_DigestKind = Core.Name "hydra.build.format.DigestKind"++_DigestKind_dslSource = Core.Name "dslSource"++_DigestKind_jsonFile = Core.Name "jsonFile"++_DigestKind_targetFile = Core.Name "targetFile"++_DigestKind_runtimeFile = Core.Name "runtimeFile"++_DigestKind_other = Core.Name "other"++-- | Configuration for the definition-documentation check+data DocumentationProfile =+  DocumentationProfile {+    -- | How a finding of this check is treated+    documentationProfileSeverity :: Severity,+    -- | Whether deprecated definitions are exempt from the documentation requirement+    documentationProfileExemptDeprecated :: Bool}+  deriving (Eq, Ord, Read, Show)++_DocumentationProfile = Core.Name "hydra.build.format.DocumentationProfile"++_DocumentationProfile_severity = Core.Name "severity"++_DocumentationProfile_exemptDeprecated = Core.Name "exemptDeprecated"++-- | A structured generation-provenance record for generated artifacts, separating gating identity from informational provenance. Only generatorId gates cache freshness; it is host-independent by design, since self-hosting requires every host to produce byte-identical output. All other fields are informational and must not gate. Invariant: a shim-mode generation has a revision (a shim has no release version, so the working-tree revision is its only precise identity).+data Generation =+  Generation {+    -- | The gating cache key identifying the generator that produced the outputs+    generationGeneratorId :: String,+    -- | Whether the artifact was produced by a published host or a locally-built migration shim+    generationMode :: GenerationMode,+    -- | The producing host language (informational)+    generationHost :: LanguageName,+    -- | The release version of the producing host (informational; omitted for shim builds)+    generationHydraVersion :: (Maybe Packaging.Version),+    -- | The producing worktree's revision, as <short-sha> with "-dirty" appended when the tree has uncommitted changes (informational; required for shim builds)+    generationRevision :: (Maybe String),+    -- | The ISO-8601 UTC time of generation (informational; non-deterministic across byte-identical rebuilds)+    generationTimestamp :: (Maybe String)}+  deriving (Eq, Ord, Read, Show)++_Generation = Core.Name "hydra.build.format.Generation"++_Generation_generatorId = Core.Name "generatorId"++_Generation_mode = Core.Name "mode"++_Generation_host = Core.Name "host"++_Generation_hydraVersion = Core.Name "hydraVersion"++_Generation_revision = Core.Name "revision"++_Generation_timestamp = Core.Name "timestamp"++-- | The provenance class of a generated artifact+data GenerationMode =+  -- | Produced by a published, versioned host+  GenerationModePublished |+  -- | Produced by a locally-built migration shim, ahead of any published host+  GenerationModeShim+  deriving (Eq, Ord, Read, Show)++_GenerationMode = Core.Name "hydra.build.format.GenerationMode"++_GenerationMode_published = Core.Name "published"++_GenerationMode_shim = Core.Name "shim"++-- | An override of the default published-host consumption for one host language: either force a local from-source build, or pin a specific published version.+data HostOverride =+  -- | Build and consume the host locally from source rather than from the package registry+  HostOverrideLocal |+  -- | Pin the host to a specific published version+  HostOverrideVersion Packaging.Version+  deriving (Eq, Ord, Read, Show)++_HostOverride = Core.Name "hydra.build.format.HostOverride"++_HostOverride_local = Core.Name "local"++_HostOverride_version = Core.Name "version"++-- | A per-package, per-source-set input digest (dist/json/<pkg>/build/<set>/digest.json): Merkle-style hashes of the package's DSL sources, recorded when the package's JSON is written and consumed by downstream freshness checks. The selfHash summarizes the package's own module hashes; dependencyHashes captures the selfHash of each declared dependency package at write time, giving transitive invalidation.+data InputDigest =+  InputDigest {+    -- | The version of this digest file's own schema+    inputDigestDigestFormatVersion :: Int,+    -- | The version of the JSON encoding of the sibling module files+    inputDigestModuleFormatVersion :: Int,+    -- | A deterministic hash over all of the package's per-module hashes (absent in legacy digests)+    inputDigestSelfHash :: (Maybe Sha256Hash),+    -- | For each declared dependency package, that package's selfHash as recorded at write time+    inputDigestDependencyHashes :: (M.Map Packaging.PackageName Sha256Hash),+    -- | The hash of each module's source, keyed by module name+    inputDigestModuleHashes :: (M.Map Packaging.ModuleName Sha256Hash)}+  deriving (Eq, Ord, Read, Show)++_InputDigest = Core.Name "hydra.build.format.InputDigest"++_InputDigest_digestFormatVersion = Core.Name "digestFormatVersion"++_InputDigest_moduleFormatVersion = Core.Name "moduleFormatVersion"++_InputDigest_selfHash = Core.Name "selfHash"++_InputDigest_dependencyHashes = Core.Name "dependencyHashes"++_InputDigest_moduleHashes = Core.Name "moduleHashes"++-- | The name of a source or target language in Hydra's build system, e.g. "haskell", "java", or "python"+newtype LanguageName =+  LanguageName {+    unLanguageName :: String}+  deriving (Eq, Ord, Read, Show)++_LanguageName = Core.Name "hydra.build.format.LanguageName"++-- | Validation rules applying to a module as a whole. Absent fields mean the corresponding check is not configured.+data ModuleValidationProfile =+  ModuleValidationProfile {+    -- | Validation rules applying to the module's individual definitions+    moduleValidationProfileDefinitions :: (Maybe DefinitionValidationProfile),+    -- | Whether module names must follow naming conventions+    moduleValidationProfileNameConvention :: (Maybe Severity),+    -- | Whether union variant names conflicting across the module are reported+    moduleValidationProfileConflictingVariantName :: (Maybe Severity)}+  deriving (Eq, Ord, Read, Show)++_ModuleValidationProfile = Core.Name "hydra.build.format.ModuleValidationProfile"++_ModuleValidationProfile_definitions = Core.Name "definitions"++_ModuleValidationProfile_nameConvention = Core.Name "nameConvention"++_ModuleValidationProfile_conflictingVariantName = Core.Name "conflictingVariantName"++-- | A per-package, per-source-set output digest for one target language (dist/<lang>/<pkg>/build/<set>/digest.json), recording every input file whose content determines the generated output, every output file the generation step is responsible for, and the identity of the generator. A generation step is fresh exactly when all input hashes, all output hashes, the generator identity, and the recorded package and dependency hashes match.+data OutputDigest =+  OutputDigest {+    -- | The version of this digest file's own schema+    outputDigestDigestFormatVersion :: Int,+    -- | The version of the JSON encoding of the module files this digest governs+    outputDigestModuleFormatVersion :: Int,+    -- | The flat gating generator identity (a compatibility duplicate of generation.generatorId)+    outputDigestGenerator :: String,+    -- | The structured generation-provenance record+    outputDigestGeneration :: Generation,+    -- | The input package's selfHash as recorded at refresh time (absent in legacy digests)+    outputDigestSelfHash :: (Maybe Sha256Hash),+    -- | For each declared dependency package, that package's selfHash as recorded at refresh time+    outputDigestDependencyHashes :: (M.Map Packaging.PackageName Sha256Hash),+    -- | Every input file's kind and hash, keyed by worktree-relative path+    outputDigestInputs :: (M.Map String DigestEntry),+    -- | Every output file's kind and hash, keyed by path relative to the output directory+    outputDigestOutputs :: (M.Map String DigestEntry)}+  deriving (Eq, Ord, Read, Show)++_OutputDigest = Core.Name "hydra.build.format.OutputDigest"++_OutputDigest_digestFormatVersion = Core.Name "digestFormatVersion"++_OutputDigest_moduleFormatVersion = Core.Name "moduleFormatVersion"++_OutputDigest_generator = Core.Name "generator"++_OutputDigest_generation = Core.Name "generation"++_OutputDigest_selfHash = Core.Name "selfHash"++_OutputDigest_dependencyHashes = Core.Name "dependencyHashes"++_OutputDigest_inputs = Core.Name "inputs"++_OutputDigest_outputs = Core.Name "outputs"++-- | A package descriptor (packages/<pkg>/package.json): the source-of-truth declaration of a Hydra package's name, source language, dependencies, and optional per-package configuration.+data PackageDescriptor =+  PackageDescriptor {+    -- | The version of this descriptor file's schema+    packageDescriptorPackageFormatVersion :: Int,+    -- | The unique name of the package, e.g. "hydra-kernel"+    packageDescriptorName :: Packaging.PackageName,+    -- | A concise human-readable summary of the package+    packageDescriptorDescription :: String,+    -- | The language in which the package's DSL sources are authored+    packageDescriptorSourceLanguage :: LanguageName,+    -- | The target languages for which distributions of this package are generated. When absent, the default target set applies.+    packageDescriptorTargetLanguages :: (Maybe [LanguageName]),+    -- | The names of the packages this package depends upon+    packageDescriptorDependencies :: [Packaging.PackageName],+    -- | Optional per-package validation configuration. When absent, the validation engine's defaults apply.+    packageDescriptorValidation :: (Maybe PackageValidationConfiguration)}+  deriving (Eq, Ord, Read, Show)++_PackageDescriptor = Core.Name "hydra.build.format.PackageDescriptor"++_PackageDescriptor_packageFormatVersion = Core.Name "packageFormatVersion"++_PackageDescriptor_name = Core.Name "name"++_PackageDescriptor_description = Core.Name "description"++_PackageDescriptor_sourceLanguage = Core.Name "sourceLanguage"++_PackageDescriptor_targetLanguages = Core.Name "targetLanguages"++_PackageDescriptor_dependencies = Core.Name "dependencies"++_PackageDescriptor_validation = Core.Name "validation"++-- | A generated-source manifest (dist/<lang>/<pkg>/src/<set>/<lang>/manifest.json): the list of modules generated into a distribution package, partitioned by role.+data PackageManifest =+  PackageManifest {+    -- | The version of this manifest file's schema+    packageManifestManifestFormatVersion :: Int,+    -- | The version of the JSON encoding of the sibling module files+    packageManifestModuleFormatVersion :: Int,+    -- | The name of the package this manifest describes+    packageManifestPackage :: Packaging.PackageName,+    -- | All main-source-set modules in the package+    packageManifestMainModules :: [Packaging.ModuleName],+    -- | All test-source-set modules in the package+    packageManifestTestModules :: [Packaging.ModuleName],+    -- | The subset of main modules which define type schemas and give rise to generated DSL wrapper modules+    packageManifestMainDslModules :: [Packaging.ModuleName],+    -- | The subset of main modules for which encoding and decoding modules are generated+    packageManifestMainEncodingModules :: [Packaging.ModuleName]}+  deriving (Eq, Ord, Read, Show)++_PackageManifest = Core.Name "hydra.build.format.PackageManifest"++_PackageManifest_manifestFormatVersion = Core.Name "manifestFormatVersion"++_PackageManifest_moduleFormatVersion = Core.Name "moduleFormatVersion"++_PackageManifest_package = Core.Name "package"++_PackageManifest_mainModules = Core.Name "mainModules"++_PackageManifest_testModules = Core.Name "testModules"++_PackageManifest_mainDslModules = Core.Name "mainDslModules"++_PackageManifest_mainEncodingModules = Core.Name "mainEncodingModules"++-- | The full, opt-in validation configuration for a package, as declared in its package descriptor. Every field cascades optional; an absent field means the corresponding rule family is not configured and the validation engine's defaults apply.+data PackageValidationConfiguration =+  PackageValidationConfiguration {+    -- | Validation rules applying to the package as a whole+    packageValidationConfigurationPackage :: (Maybe PackageValidationProfile),+    -- | Validation rules applying to each module+    packageValidationConfigurationModule :: (Maybe ModuleValidationProfile),+    -- | Validation rules applying to type-definition bodies+    packageValidationConfigurationType :: (Maybe TypeValidationProfile),+    -- | Validation rules applying to term-definition bodies+    packageValidationConfigurationTerm :: (Maybe TermValidationProfile)}+  deriving (Eq, Ord, Read, Show)++_PackageValidationConfiguration = Core.Name "hydra.build.format.PackageValidationConfiguration"++_PackageValidationConfiguration_package = Core.Name "package"++_PackageValidationConfiguration_module = Core.Name "module"++_PackageValidationConfiguration_type = Core.Name "type"++_PackageValidationConfiguration_term = Core.Name "term"++-- | Validation rules applying to a package as a whole. Absent fields mean the corresponding check is not configured.+data PackageValidationProfile =+  PackageValidationProfile {+    -- | Whether module names conflicting across the package are reported+    packageValidationProfileConflictingModuleName :: (Maybe Severity),+    -- | Whether duplicate module names within the package are reported+    packageValidationProfileDuplicateModuleName :: (Maybe Severity),+    -- | Whether package names must follow naming conventions+    packageValidationProfileNameConvention :: (Maybe Severity)}+  deriving (Eq, Ord, Read, Show)++_PackageValidationProfile = Core.Name "hydra.build.format.PackageValidationProfile"++_PackageValidationProfile_conflictingModuleName = Core.Name "conflictingModuleName"++_PackageValidationProfile_duplicateModuleName = Core.Name "duplicateModuleName"++_PackageValidationProfile_nameConvention = Core.Name "nameConvention"++-- | The repository descriptor (hydra.json at the repository root): release and host versions, host consumption overrides, publication metadata, and the list of source packages.+data RepositoryDescriptor =+  RepositoryDescriptor {+    -- | The version currently under development+    repositoryDescriptorCurrentVersion :: Packaging.Version,+    -- | The published host version consumed by default when generating code+    repositoryDescriptorHostVersion :: Packaging.Version,+    -- | Per-host-language overrides of the default published-host consumption+    repositoryDescriptorHostOverrides :: (M.Map LanguageName HostOverride),+    -- | The group identifier under which artifacts are published, e.g. a Maven group id+    repositoryDescriptorGroup :: String,+    -- | The author attribution for published artifacts+    repositoryDescriptorAuthor :: String,+    -- | The URL of the project+    repositoryDescriptorUrl :: String,+    -- | The license identifier for published artifacts, e.g. "Apache-2.0"+    repositoryDescriptorLicense :: String,+    -- | The names of the repository's source packages+    repositoryDescriptorPackages :: [Packaging.PackageName]}+  deriving (Eq, Ord, Read, Show)++_RepositoryDescriptor = Core.Name "hydra.build.format.RepositoryDescriptor"++_RepositoryDescriptor_currentVersion = Core.Name "currentVersion"++_RepositoryDescriptor_hostVersion = Core.Name "hostVersion"++_RepositoryDescriptor_hostOverrides = Core.Name "hostOverrides"++_RepositoryDescriptor_group = Core.Name "group"++_RepositoryDescriptor_author = Core.Name "author"++_RepositoryDescriptor_url = Core.Name "url"++_RepositoryDescriptor_license = Core.Name "license"++_RepositoryDescriptor_packages = Core.Name "packages"++-- | How a validation finding is treated+data Severity =+  SeverityError |+  SeverityWarning+  deriving (Eq, Ord, Read, Show)++_Severity = Core.Name "hydra.build.format.Severity"++_Severity_error = Core.Name "error"++_Severity_warning = Core.Name "warning"++-- | A SHA-256 hash in lowercase hexadecimal notation+newtype Sha256Hash =+  Sha256Hash {+    unSha256Hash :: String}+  deriving (Eq, Ord, Read, Show)++_Sha256Hash = Core.Name "hydra.build.format.Sha256Hash"++-- | Validation rules applying to term-definition bodies. Absent fields mean the corresponding check is not configured.+data TermValidationProfile =+  TermValidationProfile {+    -- | Whether duplicate let bindings are reported+    termValidationProfileDuplicateBinding :: (Maybe Severity),+    -- | Whether empty term annotations are reported+    termValidationProfileEmptyTermAnnotation :: (Maybe Severity),+    -- | Whether references to undefined variables are reported+    termValidationProfileUndefinedVariable :: (Maybe Severity)}+  deriving (Eq, Ord, Read, Show)++_TermValidationProfile = Core.Name "hydra.build.format.TermValidationProfile"++_TermValidationProfile_duplicateBinding = Core.Name "duplicateBinding"++_TermValidationProfile_emptyTermAnnotation = Core.Name "emptyTermAnnotation"++_TermValidationProfile_undefinedVariable = Core.Name "undefinedVariable"++-- | Validation rules applying to type-definition bodies. Absent fields mean the corresponding check is not configured.+data TypeValidationProfile =+  TypeValidationProfile {+    -- | Whether empty type annotations are reported+    typeValidationProfileEmptyAnnotation :: (Maybe Severity),+    -- | Whether duplicate field names within a record or union are reported+    typeValidationProfileDuplicateField :: (Maybe Severity),+    -- | Whether single-variant unions are reported+    typeValidationProfileSingleVariantUnion :: (Maybe Severity)}+  deriving (Eq, Ord, Read, Show)++_TypeValidationProfile = Core.Name "hydra.build.format.TypeValidationProfile"++_TypeValidationProfile_emptyAnnotation = Core.Name "emptyAnnotation"++_TypeValidationProfile_duplicateField = Core.Name "duplicateField"++_TypeValidationProfile_singleVariantUnion = Core.Name "singleVariantUnion"

@@ -0,0 +1,67 @@+-- Note: this is an automatically generated file. Do not edit.++-- | The translingual expected-libraries registry: every hydra.lib.<sub> module name every self-hosting host must register, load, and test. See https://github.com/CategoricalData/hydra/issues/533++module Hydra.Build.Libraries 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.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 Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci++-- | Every hydra.lib.<sub> module name every self-hosting host must register+expectedLibraries :: [String]+expectedLibraries =+    [+      "chars",+      "effects",+      "eithers",+      "equality",+      "files",+      "functions",+      "hashing",+      "lists",+      "literals",+      "logic",+      "maps",+      "math",+      "optionals",+      "ordering",+      "pairs",+      "regex",+      "sets",+      "strings",+      "system",+      "text"]++-- | Whether a bare sub-namespace name is a member of expectedLibraries+isExpectedLibrary :: String -> Bool+isExpectedLibrary sub = Lists.member sub expectedLibraries

@@ -0,0 +1,57 @@+-- Note: this is an automatically generated file. Do not edit.++-- | Per-package manifest.json field-assembly and serialization logic shared by the code-generation drivers++module Hydra.Build.ManifestWriter 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.Literals as Literals+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 Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci++-- | The manifest.json contents for one package: field assembly + serialization, given the package name and its main/dsl/encoding/test module lists+packageManifestJson :: String -> [Packaging.Module] -> [Packaging.Module] -> [Packaging.Module] -> [Packaging.Module] -> Model.Value+packageManifestJson pkg mainMods dslMods encMods testMods =+    Model.ValueObject [+      ("mainDslModules", (sortedNamespaces dslMods)),+      ("mainEncodingModules", (sortedNamespaces encMods)),+      ("mainModules", (sortedNamespaces mainMods)),+      ("manifestFormatVersion", (Model.ValueNumber (Literals.bigintToDecimal 1))),+      ("package", (Model.ValueString pkg)),+      ("testModules", (sortedNamespaces testMods))]++-- | The sorted namespace strings of a list of modules, as a JSON string array+sortedNamespaces :: [Packaging.Module] -> Model.Value+sortedNamespaces mods =++      let names = Lists.sort (Lists.map (\m -> Packaging.unModuleName (Packaging.moduleName m)) mods)+      in (Model.ValueArray (Lists.map (\n -> Model.ValueString n) names))

@@ -17,10 +17,10 @@ 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.Logic as Logic 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@@ -45,7 +45,7 @@  -- | Deduplicate a list of strings, preserving first-occurrence order dedupPreservingOrder :: Eq t0 => ([t0] -> [t0])-dedupPreservingOrder xs = Lists.nub xs+dedupPreservingOrder xs = Lists.distinct xs  -- | Keep only modules outside the hydra.* and hydra.json.yaml.* namespaces filterKernelModules :: [Packaging.Module] -> [Packaging.Module]@@ -71,7 +71,7 @@ secondLevelDir rel =        let parts = Strings.splitOn "/" rel-      in (Logic.ifElse (Equality.lt (Lists.length parts) 2) Nothing (Just (Strings.intercalate "/" (Lists.take 2 parts))))+      in (Logic.ifElse (Ordering.lt (Lists.length parts) 2) Nothing (Just (Strings.join "/" (Lists.take 2 parts))))  -- | Strip System F type annotations from every module in a list stripAllTermTypes :: [Packaging.Module] -> [Packaging.Module]

@@ -22,6 +22,7 @@ import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Overlay.Haskell.Lib.Ordering as Ordering import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings import qualified Hydra.Packaging as Packaging@@ -49,9 +50,9 @@ extensionOf path =        let segs = Strings.splitOn "/" path-      in (Optionals.cases (Lists.maybeLast segs) Nothing (\fileName ->+      in (Optionals.cases (Lists.last segs) Nothing (\fileName ->         let dotParts = Strings.splitOn "." fileName-        in (Logic.ifElse (Equality.gt (Lists.length dotParts) 1) (Lists.maybeLast dotParts) Nothing)))+        in (Logic.ifElse (Ordering.gt (Lists.length dotParts) 1) (Lists.last dotParts) Nothing)))  -- | Whether a relative path lies under at least one prefix, matched segment-wise isUnderAnyPrefix :: S.Set String -> String -> Bool@@ -65,7 +66,7 @@ -- | The keep-set of relative JSON paths (moduleNameToPath(ns) ++ .json) for written modules keepPathsForModules :: [Packaging.ModuleName] -> S.Set String keepPathsForModules mods =-    Sets.fromList (Lists.map (\m -> Strings.cat [+    Sets.fromList (Lists.map (\m -> Strings.concat [       Codegen.moduleNameToPath m,       ".json"]) mods) @@ -93,4 +94,4 @@ secondLevelDir path =        let segs = Strings.splitOn "/" path-      in (Logic.ifElse (Equality.gte (Lists.length segs) 2) (Just (Strings.intercalate "/" (Lists.take 2 segs))) Nothing)+      in (Logic.ifElse (Ordering.gte (Lists.length segs) 2) (Just (Strings.join "/" (Lists.take 2 segs))) Nothing)

@@ -75,13 +75,13 @@ groupByPackageIn rm mods =        let step =-              \acc -> \m -> Eithers.bind acc (\grouped -> Eithers.bind (namespaceToPackageIn rm (Packaging.moduleName m)) (\pkg -> Right (Maps.alter (\mods0 -> Just (Lists.cons m (Optionals.fromOptional [] mods0))) pkg grouped)))+              \acc -> \m -> Eithers.bind acc (\grouped -> Eithers.bind (namespaceToPackageIn rm (Packaging.moduleName m)) (\pkg -> Right (Maps.alter (\mods0 -> Just (Lists.cons m (Optionals.withDefault [] mods0))) pkg grouped)))       in (Eithers.map (\grouped -> Maps.toList grouped) (Lists.foldl step (Right Maps.empty) mods))  -- | Map a module name to the package that owns it, failing loudly if unrouted namespaceToPackageIn :: M.Map Packaging.ModuleName t0 -> Packaging.ModuleName -> Either Errors.Error t0 namespaceToPackageIn rm ns =-    Optionals.cases (Maps.lookup ns rm) (Left (Errors.ErrorOther (Errors.OtherError (Strings.cat [+    Optionals.cases (Maps.lookup ns rm) (Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [       "unrouted module: ",       (Packaging.unModuleName ns),       " is not declared in any package's manifest (RoutingMap). Add it to the owning package's Manifest.mainModules."])))) (\p -> Right p)@@ -92,9 +92,9 @@        let parts = Strings.splitOn "." (Packaging.unModuleName ns)           fallback =-                  Packaging.ModuleName (Strings.cat [+                  Packaging.ModuleName (Strings.concat [                     "hydra.sources.",                     (Packaging.unModuleName ns)])-      in (Optionals.cases (Lists.uncons parts) fallback (\uc -> Packaging.ModuleName (Strings.cat [+      in (Optionals.cases (Lists.uncons parts) fallback (\uc -> Packaging.ModuleName (Strings.concat [         "hydra.sources.",-        (Strings.intercalate "." (Pairs.second uc))])))+        (Strings.join "." (Pairs.second uc))])))

@@ -0,0 +1,415 @@+-- Note: this is an automatically generated file. Do not edit.++-- | Term decoders for hydra.build.format++module Hydra.Decode.Build.Format where++import qualified Hydra.Build.Format as Format+import qualified Hydra.Core as Core+import qualified Hydra.Decode.Packaging as Packaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Extract.Core as ExtractCore+import qualified Hydra.Graph as Graph+import qualified Hydra.Lexical as Lexical+import qualified Hydra.Overlay.Haskell.Lib.Eithers as Eithers+import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps+import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings+import qualified Hydra.Rewriting as Rewriting+import qualified Hydra.Util as Util+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci++-- | Decoder for hydra.build.format.DefinitionNameConventionProfile+definitionNameConventionProfile :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.DefinitionNameConventionProfile+definitionNameConventionProfile cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "severity" severity fieldMap cx) (\field_severity -> Eithers.bind (ExtractCore.requireField "allowUnderscores" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Core.TermLiteral v1 -> case v1 of+            Core.LiteralBoolean v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected boolean literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.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")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.DefinitionValidationProfile+definitionValidationProfile :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.DefinitionValidationProfile+definitionValidationProfile cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "hasDescription" (ExtractCore.decodeMaybe documentationProfile) fieldMap cx) (\field_hasDescription -> Eithers.bind (ExtractCore.requireField "ordering" (ExtractCore.decodeMaybe severity) fieldMap cx) (\field_ordering -> Eithers.bind (ExtractCore.requireField "nameConvention" (ExtractCore.decodeMaybe definitionNameConventionProfile) fieldMap cx) (\field_nameConvention -> Eithers.bind (ExtractCore.requireField "notInModuleName" (ExtractCore.decodeMaybe severity) fieldMap cx) (\field_notInModuleName -> Eithers.bind (ExtractCore.requireField "duplicateName" (ExtractCore.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")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.DigestEntry+digestEntry :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.DigestEntry+digestEntry cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "kind" digestKind fieldMap cx) (\field_kind -> Eithers.bind (ExtractCore.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")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.DigestKind+digestKind :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.DigestKind+digestKind cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermInject v0 ->+        let field = Core.injectionField v0+            fname = Core.fieldName field+            fterm = Core.fieldTerm field+            variantMap =+                    Maps.fromList [+                      (Core.Name "dslSource", (\input -> Eithers.map (\t -> Format.DigestKindDslSource) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "jsonFile", (\input -> Eithers.map (\t -> Format.DigestKindJsonFile) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "targetFile", (\input -> Eithers.map (\t -> Format.DigestKindTargetFile) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "runtimeFile", (\input -> Eithers.map (\t -> Format.DigestKindRuntimeFile) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "other", (\input -> Eithers.map (\t -> Format.DigestKindOther) (ExtractCore.decodeUnit cx input)))]+        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+          "no such field ",+          (Core.unName fname),+          " in union"]))) (\f -> f fterm))+      _ -> Left (Errors.DecodingError "expected union")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.DocumentationProfile+documentationProfile :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.DocumentationProfile+documentationProfile cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "severity" severity fieldMap cx) (\field_severity -> Eithers.bind (ExtractCore.requireField "exemptDeprecated" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Core.TermLiteral v1 -> case v1 of+            Core.LiteralBoolean v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected boolean literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.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")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.Generation+generation :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.Generation+generation cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "generatorId" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Core.TermLiteral v1 -> case v1 of+            Core.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_generatorId -> Eithers.bind (ExtractCore.requireField "mode" generationMode fieldMap cx) (\field_mode -> Eithers.bind (ExtractCore.requireField "host" languageName fieldMap cx) (\field_host -> Eithers.bind (ExtractCore.requireField "hydraVersion" (ExtractCore.decodeMaybe Packaging.version) fieldMap cx) (\field_hydraVersion -> Eithers.bind (ExtractCore.requireField "revision" (ExtractCore.decodeMaybe (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Core.TermLiteral v1 -> case v1 of+            Core.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2))) fieldMap cx) (\field_revision -> Eithers.bind (ExtractCore.requireField "timestamp" (ExtractCore.decodeMaybe (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Core.TermLiteral v1 -> case v1 of+            Core.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.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")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.GenerationMode+generationMode :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.GenerationMode+generationMode cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermInject v0 ->+        let field = Core.injectionField v0+            fname = Core.fieldName field+            fterm = Core.fieldTerm field+            variantMap =+                    Maps.fromList [+                      (Core.Name "published", (\input -> Eithers.map (\t -> Format.GenerationModePublished) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "shim", (\input -> Eithers.map (\t -> Format.GenerationModeShim) (ExtractCore.decodeUnit cx input)))]+        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+          "no such field ",+          (Core.unName fname),+          " in union"]))) (\f -> f fterm))+      _ -> Left (Errors.DecodingError "expected union")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.HostOverride+hostOverride :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.HostOverride+hostOverride cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermInject v0 ->+        let field = Core.injectionField v0+            fname = Core.fieldName field+            fterm = Core.fieldTerm field+            variantMap =+                    Maps.fromList [+                      (Core.Name "local", (\input -> Eithers.map (\t -> Format.HostOverrideLocal) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "version", (\input -> Eithers.map (\t -> Format.HostOverrideVersion t) (Packaging.version cx input)))]+        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+          "no such field ",+          (Core.unName fname),+          " in union"]))) (\f -> f fterm))+      _ -> Left (Errors.DecodingError "expected union")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.InputDigest+inputDigest :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.InputDigest+inputDigest cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "digestFormatVersion" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Core.TermLiteral v1 -> case v1 of+            Core.LiteralInteger v2 -> case v2 of+              Core.IntegerValueInt32 v3 -> Right v3+              _ -> Left (Errors.DecodingError "expected int32 value")+            _ -> Left (Errors.DecodingError "expected int32 literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_digestFormatVersion -> Eithers.bind (ExtractCore.requireField "moduleFormatVersion" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Core.TermLiteral v1 -> case v1 of+            Core.LiteralInteger v2 -> case v2 of+              Core.IntegerValueInt32 v3 -> Right v3+              _ -> Left (Errors.DecodingError "expected int32 value")+            _ -> Left (Errors.DecodingError "expected int32 literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_moduleFormatVersion -> Eithers.bind (ExtractCore.requireField "selfHash" (ExtractCore.decodeMaybe sha256Hash) fieldMap cx) (\field_selfHash -> Eithers.bind (ExtractCore.requireField "dependencyHashes" (ExtractCore.decodeMap Packaging.packageName sha256Hash) fieldMap cx) (\field_dependencyHashes -> Eithers.bind (ExtractCore.requireField "moduleHashes" (ExtractCore.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")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.LanguageName+languageName :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.LanguageName+languageName cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermWrap v0 -> Eithers.map (\b -> Format.LanguageName b) ((\raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+        Core.TermLiteral v1 -> case v1 of+          Core.LiteralString v2 -> Right v2+          _ -> Left (Errors.DecodingError "expected string literal")+        _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx raw2)) (Core.wrappedTermBody v0))+      _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.ModuleValidationProfile+moduleValidationProfile :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.ModuleValidationProfile+moduleValidationProfile cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "definitions" (ExtractCore.decodeMaybe definitionValidationProfile) fieldMap cx) (\field_definitions -> Eithers.bind (ExtractCore.requireField "nameConvention" (ExtractCore.decodeMaybe severity) fieldMap cx) (\field_nameConvention -> Eithers.bind (ExtractCore.requireField "conflictingVariantName" (ExtractCore.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")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.OutputDigest+outputDigest :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.OutputDigest+outputDigest cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "digestFormatVersion" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Core.TermLiteral v1 -> case v1 of+            Core.LiteralInteger v2 -> case v2 of+              Core.IntegerValueInt32 v3 -> Right v3+              _ -> Left (Errors.DecodingError "expected int32 value")+            _ -> Left (Errors.DecodingError "expected int32 literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_digestFormatVersion -> Eithers.bind (ExtractCore.requireField "moduleFormatVersion" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Core.TermLiteral v1 -> case v1 of+            Core.LiteralInteger v2 -> case v2 of+              Core.IntegerValueInt32 v3 -> Right v3+              _ -> Left (Errors.DecodingError "expected int32 value")+            _ -> Left (Errors.DecodingError "expected int32 literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_moduleFormatVersion -> Eithers.bind (ExtractCore.requireField "generator" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Core.TermLiteral v1 -> case v1 of+            Core.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_generator -> Eithers.bind (ExtractCore.requireField "generation" generation fieldMap cx) (\field_generation -> Eithers.bind (ExtractCore.requireField "selfHash" (ExtractCore.decodeMaybe sha256Hash) fieldMap cx) (\field_selfHash -> Eithers.bind (ExtractCore.requireField "dependencyHashes" (ExtractCore.decodeMap Packaging.packageName sha256Hash) fieldMap cx) (\field_dependencyHashes -> Eithers.bind (ExtractCore.requireField "inputs" (ExtractCore.decodeMap (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Core.TermLiteral v1 -> case v1 of+            Core.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) digestEntry) fieldMap cx) (\field_inputs -> Eithers.bind (ExtractCore.requireField "outputs" (ExtractCore.decodeMap (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Core.TermLiteral v1 -> case v1 of+            Core.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.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")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.PackageDescriptor+packageDescriptor :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.PackageDescriptor+packageDescriptor cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "packageFormatVersion" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Core.TermLiteral v1 -> case v1 of+            Core.LiteralInteger v2 -> case v2 of+              Core.IntegerValueInt32 v3 -> Right v3+              _ -> Left (Errors.DecodingError "expected int32 value")+            _ -> Left (Errors.DecodingError "expected int32 literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_packageFormatVersion -> Eithers.bind (ExtractCore.requireField "name" Packaging.packageName fieldMap cx) (\field_name -> Eithers.bind (ExtractCore.requireField "description" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Core.TermLiteral v1 -> case v1 of+            Core.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_description -> Eithers.bind (ExtractCore.requireField "sourceLanguage" languageName fieldMap cx) (\field_sourceLanguage -> Eithers.bind (ExtractCore.requireField "targetLanguages" (ExtractCore.decodeMaybe (ExtractCore.decodeList languageName)) fieldMap cx) (\field_targetLanguages -> Eithers.bind (ExtractCore.requireField "dependencies" (ExtractCore.decodeList Packaging.packageName) fieldMap cx) (\field_dependencies -> Eithers.bind (ExtractCore.requireField "validation" (ExtractCore.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")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.PackageManifest+packageManifest :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.PackageManifest+packageManifest cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "manifestFormatVersion" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Core.TermLiteral v1 -> case v1 of+            Core.LiteralInteger v2 -> case v2 of+              Core.IntegerValueInt32 v3 -> Right v3+              _ -> Left (Errors.DecodingError "expected int32 value")+            _ -> Left (Errors.DecodingError "expected int32 literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_manifestFormatVersion -> Eithers.bind (ExtractCore.requireField "moduleFormatVersion" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Core.TermLiteral v1 -> case v1 of+            Core.LiteralInteger v2 -> case v2 of+              Core.IntegerValueInt32 v3 -> Right v3+              _ -> Left (Errors.DecodingError "expected int32 value")+            _ -> Left (Errors.DecodingError "expected int32 literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_moduleFormatVersion -> Eithers.bind (ExtractCore.requireField "package" Packaging.packageName fieldMap cx) (\field_package -> Eithers.bind (ExtractCore.requireField "mainModules" (ExtractCore.decodeList Packaging.moduleName) fieldMap cx) (\field_mainModules -> Eithers.bind (ExtractCore.requireField "testModules" (ExtractCore.decodeList Packaging.moduleName) fieldMap cx) (\field_testModules -> Eithers.bind (ExtractCore.requireField "mainDslModules" (ExtractCore.decodeList Packaging.moduleName) fieldMap cx) (\field_mainDslModules -> Eithers.bind (ExtractCore.requireField "mainEncodingModules" (ExtractCore.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")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.PackageValidationConfiguration+packageValidationConfiguration :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.PackageValidationConfiguration+packageValidationConfiguration cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "package" (ExtractCore.decodeMaybe packageValidationProfile) fieldMap cx) (\field_package -> Eithers.bind (ExtractCore.requireField "module" (ExtractCore.decodeMaybe moduleValidationProfile) fieldMap cx) (\field_module -> Eithers.bind (ExtractCore.requireField "type" (ExtractCore.decodeMaybe typeValidationProfile) fieldMap cx) (\field_type -> Eithers.bind (ExtractCore.requireField "term" (ExtractCore.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")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.PackageValidationProfile+packageValidationProfile :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.PackageValidationProfile+packageValidationProfile cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "conflictingModuleName" (ExtractCore.decodeMaybe severity) fieldMap cx) (\field_conflictingModuleName -> Eithers.bind (ExtractCore.requireField "duplicateModuleName" (ExtractCore.decodeMaybe severity) fieldMap cx) (\field_duplicateModuleName -> Eithers.bind (ExtractCore.requireField "nameConvention" (ExtractCore.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")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.RepositoryDescriptor+repositoryDescriptor :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.RepositoryDescriptor+repositoryDescriptor cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "currentVersion" Packaging.version fieldMap cx) (\field_currentVersion -> Eithers.bind (ExtractCore.requireField "hostVersion" Packaging.version fieldMap cx) (\field_hostVersion -> Eithers.bind (ExtractCore.requireField "hostOverrides" (ExtractCore.decodeMap languageName hostOverride) fieldMap cx) (\field_hostOverrides -> Eithers.bind (ExtractCore.requireField "group" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Core.TermLiteral v1 -> case v1 of+            Core.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_group -> Eithers.bind (ExtractCore.requireField "author" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Core.TermLiteral v1 -> case v1 of+            Core.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_author -> Eithers.bind (ExtractCore.requireField "url" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Core.TermLiteral v1 -> case v1 of+            Core.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_url -> Eithers.bind (ExtractCore.requireField "license" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          Core.TermLiteral v1 -> case v1 of+            Core.LiteralString v2 -> Right v2+            _ -> Left (Errors.DecodingError "expected string literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_license -> Eithers.bind (ExtractCore.requireField "packages" (ExtractCore.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")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.Severity+severity :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.Severity+severity cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermInject v0 ->+        let field = Core.injectionField v0+            fname = Core.fieldName field+            fterm = Core.fieldTerm field+            variantMap =+                    Maps.fromList [+                      (Core.Name "error", (\input -> Eithers.map (\t -> Format.SeverityError) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "warning", (\input -> Eithers.map (\t -> Format.SeverityWarning) (ExtractCore.decodeUnit cx input)))]+        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+          "no such field ",+          (Core.unName fname),+          " in union"]))) (\f -> f fterm))+      _ -> Left (Errors.DecodingError "expected union")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.Sha256Hash+sha256Hash :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.Sha256Hash+sha256Hash cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermWrap v0 -> Eithers.map (\b -> Format.Sha256Hash b) ((\raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+        Core.TermLiteral v1 -> case v1 of+          Core.LiteralString v2 -> Right v2+          _ -> Left (Errors.DecodingError "expected string literal")+        _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx raw2)) (Core.wrappedTermBody v0))+      _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.TermValidationProfile+termValidationProfile :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.TermValidationProfile+termValidationProfile cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "duplicateBinding" (ExtractCore.decodeMaybe severity) fieldMap cx) (\field_duplicateBinding -> Eithers.bind (ExtractCore.requireField "emptyTermAnnotation" (ExtractCore.decodeMaybe severity) fieldMap cx) (\field_emptyTermAnnotation -> Eithers.bind (ExtractCore.requireField "undefinedVariable" (ExtractCore.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")) (ExtractCore.stripWithDecodingError cx raw)++-- | Decoder for hydra.build.format.TypeValidationProfile+typeValidationProfile :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.TypeValidationProfile+typeValidationProfile cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "emptyAnnotation" (ExtractCore.decodeMaybe severity) fieldMap cx) (\field_emptyAnnotation -> Eithers.bind (ExtractCore.requireField "duplicateField" (ExtractCore.decodeMaybe severity) fieldMap cx) (\field_duplicateField -> Eithers.bind (ExtractCore.requireField "singleVariantUnion" (ExtractCore.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")) (ExtractCore.stripWithDecodingError cx raw)

@@ -0,0 +1,3988 @@+-- Note: this is an automatically generated file. Do not edit.++-- | DSL functions for hydra.build.format++module Hydra.Dsl.Build.Format where++import qualified Hydra.Build.Format as Format+import qualified Hydra.Core as Core+import qualified Hydra.Decode.Build.Format as DecodeBuildFormat+import qualified Hydra.Dsl.Packaging as DslPackaging+import qualified Hydra.Encode.Build.Format as EncodeBuildFormat+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typed as Typed+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M++-- | DSL constructor for hydra.build.format.DefinitionNameConventionProfile+definitionNameConventionProfile :: Typed.TypedTerm Format.Severity -> Typed.TypedTerm Bool -> Typed.TypedTerm Format.DefinitionNameConventionProfile+definitionNameConventionProfile severity allowUnderscores =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionNameConventionProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "severity"),+          Core.fieldTerm = (Typed.unTypedTerm severity)},+        Core.Field {+          Core.fieldName = (Core.Name "allowUnderscores"),+          Core.fieldTerm = (Typed.unTypedTerm allowUnderscores)}]}))++-- | DSL accessor for the allowUnderscores field of hydra.build.format.DefinitionNameConventionProfile+definitionNameConventionProfileAllowUnderscores :: Typed.TypedTerm Format.DefinitionNameConventionProfile -> Typed.TypedTerm Bool+definitionNameConventionProfileAllowUnderscores x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionNameConventionProfile"),+        Core.projectionFieldName = (Core.Name "allowUnderscores")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.format.DefinitionNameConventionProfile+definitionNameConventionProfileDefinitionNameConventionProfile :: Typed.TypedName Format.DefinitionNameConventionProfile+definitionNameConventionProfileDefinitionNameConventionProfile =+    Typed.TypedName (Core.Name "hydra.build.format.DefinitionNameConventionProfile")++-- | DSL accessor for the severity field of hydra.build.format.DefinitionNameConventionProfile+definitionNameConventionProfileSeverity :: Typed.TypedTerm Format.DefinitionNameConventionProfile -> Typed.TypedTerm Format.Severity+definitionNameConventionProfileSeverity x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionNameConventionProfile"),+        Core.projectionFieldName = (Core.Name "severity")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the allowUnderscores field of hydra.build.format.DefinitionNameConventionProfile+definitionNameConventionProfileWithAllowUnderscores :: Typed.TypedTerm Format.DefinitionNameConventionProfile -> Typed.TypedTerm Bool -> Typed.TypedTerm Format.DefinitionNameConventionProfile+definitionNameConventionProfileWithAllowUnderscores original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionNameConventionProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "severity"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionNameConventionProfile"),+              Core.projectionFieldName = (Core.Name "severity")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "allowUnderscores"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the severity field of hydra.build.format.DefinitionNameConventionProfile+definitionNameConventionProfileWithSeverity :: Typed.TypedTerm Format.DefinitionNameConventionProfile -> Typed.TypedTerm Format.Severity -> Typed.TypedTerm Format.DefinitionNameConventionProfile+definitionNameConventionProfileWithSeverity original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionNameConventionProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "severity"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "allowUnderscores"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionNameConventionProfile"),+              Core.projectionFieldName = (Core.Name "allowUnderscores")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.build.format.DefinitionValidationProfile+definitionValidationProfile :: Typed.TypedTerm (Maybe Format.DocumentationProfile) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.DefinitionNameConventionProfile) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.DefinitionValidationProfile+definitionValidationProfile hasDescription ordering nameConvention notInModuleName duplicateName =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "hasDescription"),+          Core.fieldTerm = (Typed.unTypedTerm hasDescription)},+        Core.Field {+          Core.fieldName = (Core.Name "ordering"),+          Core.fieldTerm = (Typed.unTypedTerm ordering)},+        Core.Field {+          Core.fieldName = (Core.Name "nameConvention"),+          Core.fieldTerm = (Typed.unTypedTerm nameConvention)},+        Core.Field {+          Core.fieldName = (Core.Name "notInModuleName"),+          Core.fieldTerm = (Typed.unTypedTerm notInModuleName)},+        Core.Field {+          Core.fieldName = (Core.Name "duplicateName"),+          Core.fieldTerm = (Typed.unTypedTerm duplicateName)}]}))++-- | DSL name token for hydra.build.format.DefinitionValidationProfile+definitionValidationProfileDefinitionValidationProfile :: Typed.TypedName Format.DefinitionValidationProfile+definitionValidationProfileDefinitionValidationProfile =+    Typed.TypedName (Core.Name "hydra.build.format.DefinitionValidationProfile")++-- | DSL accessor for the duplicateName field of hydra.build.format.DefinitionValidationProfile+definitionValidationProfileDuplicateName :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.Severity)+definitionValidationProfileDuplicateName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+        Core.projectionFieldName = (Core.Name "duplicateName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the hasDescription field of hydra.build.format.DefinitionValidationProfile+definitionValidationProfileHasDescription :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.DocumentationProfile)+definitionValidationProfileHasDescription x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+        Core.projectionFieldName = (Core.Name "hasDescription")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the nameConvention field of hydra.build.format.DefinitionValidationProfile+definitionValidationProfileNameConvention :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.DefinitionNameConventionProfile)+definitionValidationProfileNameConvention x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+        Core.projectionFieldName = (Core.Name "nameConvention")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the notInModuleName field of hydra.build.format.DefinitionValidationProfile+definitionValidationProfileNotInModuleName :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.Severity)+definitionValidationProfileNotInModuleName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+        Core.projectionFieldName = (Core.Name "notInModuleName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the ordering field of hydra.build.format.DefinitionValidationProfile+definitionValidationProfileOrdering :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.Severity)+definitionValidationProfileOrdering x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+        Core.projectionFieldName = (Core.Name "ordering")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the duplicateName field of hydra.build.format.DefinitionValidationProfile+definitionValidationProfileWithDuplicateName :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.DefinitionValidationProfile+definitionValidationProfileWithDuplicateName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "hasDescription"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+              Core.projectionFieldName = (Core.Name "hasDescription")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "ordering"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+              Core.projectionFieldName = (Core.Name "ordering")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "nameConvention"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+              Core.projectionFieldName = (Core.Name "nameConvention")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "notInModuleName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+              Core.projectionFieldName = (Core.Name "notInModuleName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "duplicateName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the hasDescription field of hydra.build.format.DefinitionValidationProfile+definitionValidationProfileWithHasDescription :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.DocumentationProfile) -> Typed.TypedTerm Format.DefinitionValidationProfile+definitionValidationProfileWithHasDescription original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "hasDescription"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "ordering"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+              Core.projectionFieldName = (Core.Name "ordering")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "nameConvention"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+              Core.projectionFieldName = (Core.Name "nameConvention")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "notInModuleName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+              Core.projectionFieldName = (Core.Name "notInModuleName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "duplicateName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+              Core.projectionFieldName = (Core.Name "duplicateName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the nameConvention field of hydra.build.format.DefinitionValidationProfile+definitionValidationProfileWithNameConvention :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.DefinitionNameConventionProfile) -> Typed.TypedTerm Format.DefinitionValidationProfile+definitionValidationProfileWithNameConvention original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "hasDescription"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+              Core.projectionFieldName = (Core.Name "hasDescription")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "ordering"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+              Core.projectionFieldName = (Core.Name "ordering")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "nameConvention"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "notInModuleName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+              Core.projectionFieldName = (Core.Name "notInModuleName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "duplicateName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+              Core.projectionFieldName = (Core.Name "duplicateName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the notInModuleName field of hydra.build.format.DefinitionValidationProfile+definitionValidationProfileWithNotInModuleName :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.DefinitionValidationProfile+definitionValidationProfileWithNotInModuleName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "hasDescription"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+              Core.projectionFieldName = (Core.Name "hasDescription")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "ordering"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+              Core.projectionFieldName = (Core.Name "ordering")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "nameConvention"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+              Core.projectionFieldName = (Core.Name "nameConvention")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "notInModuleName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "duplicateName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+              Core.projectionFieldName = (Core.Name "duplicateName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the ordering field of hydra.build.format.DefinitionValidationProfile+definitionValidationProfileWithOrdering :: Typed.TypedTerm Format.DefinitionValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.DefinitionValidationProfile+definitionValidationProfileWithOrdering original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "hasDescription"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+              Core.projectionFieldName = (Core.Name "hasDescription")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "ordering"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "nameConvention"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+              Core.projectionFieldName = (Core.Name "nameConvention")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "notInModuleName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+              Core.projectionFieldName = (Core.Name "notInModuleName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "duplicateName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+              Core.projectionFieldName = (Core.Name "duplicateName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.build.format.DigestEntry+digestEntry :: Typed.TypedTerm Format.DigestKind -> Typed.TypedTerm Format.Sha256Hash -> Typed.TypedTerm Format.DigestEntry+digestEntry kind hash =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.DigestEntry"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "kind"),+          Core.fieldTerm = (Typed.unTypedTerm kind)},+        Core.Field {+          Core.fieldName = (Core.Name "hash"),+          Core.fieldTerm = (Typed.unTypedTerm hash)}]}))++-- | DSL name token for hydra.build.format.DigestEntry+digestEntryDigestEntry :: Typed.TypedName Format.DigestEntry+digestEntryDigestEntry = Typed.TypedName (Core.Name "hydra.build.format.DigestEntry")++-- | DSL accessor for the hash field of hydra.build.format.DigestEntry+digestEntryHash :: Typed.TypedTerm Format.DigestEntry -> Typed.TypedTerm Format.Sha256Hash+digestEntryHash x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.DigestEntry"),+        Core.projectionFieldName = (Core.Name "hash")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the kind field of hydra.build.format.DigestEntry+digestEntryKind :: Typed.TypedTerm Format.DigestEntry -> Typed.TypedTerm Format.DigestKind+digestEntryKind x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.DigestEntry"),+        Core.projectionFieldName = (Core.Name "kind")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the hash field of hydra.build.format.DigestEntry+digestEntryWithHash :: Typed.TypedTerm Format.DigestEntry -> Typed.TypedTerm Format.Sha256Hash -> Typed.TypedTerm Format.DigestEntry+digestEntryWithHash original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.DigestEntry"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "kind"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.DigestEntry"),+              Core.projectionFieldName = (Core.Name "kind")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "hash"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the kind field of hydra.build.format.DigestEntry+digestEntryWithKind :: Typed.TypedTerm Format.DigestEntry -> Typed.TypedTerm Format.DigestKind -> Typed.TypedTerm Format.DigestEntry+digestEntryWithKind original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.DigestEntry"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "kind"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "hash"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.DigestEntry"),+              Core.projectionFieldName = (Core.Name "hash")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL name token for hydra.build.format.DigestKind+digestKindDigestKind :: Typed.TypedName Format.DigestKind+digestKindDigestKind = Typed.TypedName (Core.Name "hydra.build.format.DigestKind")++-- | DSL injection for the dslSource variant of hydra.build.format.DigestKind+digestKindDslSource :: Typed.TypedTerm Format.DigestKind+digestKindDslSource =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.build.format.DigestKind"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "dslSource"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the jsonFile variant of hydra.build.format.DigestKind+digestKindJsonFile :: Typed.TypedTerm Format.DigestKind+digestKindJsonFile =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.build.format.DigestKind"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "jsonFile"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the other variant of hydra.build.format.DigestKind+digestKindOther :: Typed.TypedTerm Format.DigestKind+digestKindOther =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.build.format.DigestKind"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "other"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the runtimeFile variant of hydra.build.format.DigestKind+digestKindRuntimeFile :: Typed.TypedTerm Format.DigestKind+digestKindRuntimeFile =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.build.format.DigestKind"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "runtimeFile"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the targetFile variant of hydra.build.format.DigestKind+digestKindTargetFile :: Typed.TypedTerm Format.DigestKind+digestKindTargetFile =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.build.format.DigestKind"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "targetFile"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL constructor for hydra.build.format.DocumentationProfile+documentationProfile :: Typed.TypedTerm Format.Severity -> Typed.TypedTerm Bool -> Typed.TypedTerm Format.DocumentationProfile+documentationProfile severity exemptDeprecated =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.DocumentationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "severity"),+          Core.fieldTerm = (Typed.unTypedTerm severity)},+        Core.Field {+          Core.fieldName = (Core.Name "exemptDeprecated"),+          Core.fieldTerm = (Typed.unTypedTerm exemptDeprecated)}]}))++-- | DSL name token for hydra.build.format.DocumentationProfile+documentationProfileDocumentationProfile :: Typed.TypedName Format.DocumentationProfile+documentationProfileDocumentationProfile = Typed.TypedName (Core.Name "hydra.build.format.DocumentationProfile")++-- | DSL accessor for the exemptDeprecated field of hydra.build.format.DocumentationProfile+documentationProfileExemptDeprecated :: Typed.TypedTerm Format.DocumentationProfile -> Typed.TypedTerm Bool+documentationProfileExemptDeprecated x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.DocumentationProfile"),+        Core.projectionFieldName = (Core.Name "exemptDeprecated")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the severity field of hydra.build.format.DocumentationProfile+documentationProfileSeverity :: Typed.TypedTerm Format.DocumentationProfile -> Typed.TypedTerm Format.Severity+documentationProfileSeverity x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.DocumentationProfile"),+        Core.projectionFieldName = (Core.Name "severity")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the exemptDeprecated field of hydra.build.format.DocumentationProfile+documentationProfileWithExemptDeprecated :: Typed.TypedTerm Format.DocumentationProfile -> Typed.TypedTerm Bool -> Typed.TypedTerm Format.DocumentationProfile+documentationProfileWithExemptDeprecated original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.DocumentationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "severity"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.DocumentationProfile"),+              Core.projectionFieldName = (Core.Name "severity")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "exemptDeprecated"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the severity field of hydra.build.format.DocumentationProfile+documentationProfileWithSeverity :: Typed.TypedTerm Format.DocumentationProfile -> Typed.TypedTerm Format.Severity -> Typed.TypedTerm Format.DocumentationProfile+documentationProfileWithSeverity original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.DocumentationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "severity"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "exemptDeprecated"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.DocumentationProfile"),+              Core.projectionFieldName = (Core.Name "exemptDeprecated")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.build.format.Generation+generation :: Typed.TypedTerm String -> Typed.TypedTerm Format.GenerationMode -> Typed.TypedTerm Format.LanguageName -> Typed.TypedTerm (Maybe Packaging.Version) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Format.Generation+generation generatorId mode host hydraVersion revision timestamp =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.Generation"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "generatorId"),+          Core.fieldTerm = (Typed.unTypedTerm generatorId)},+        Core.Field {+          Core.fieldName = (Core.Name "mode"),+          Core.fieldTerm = (Typed.unTypedTerm mode)},+        Core.Field {+          Core.fieldName = (Core.Name "host"),+          Core.fieldTerm = (Typed.unTypedTerm host)},+        Core.Field {+          Core.fieldName = (Core.Name "hydraVersion"),+          Core.fieldTerm = (Typed.unTypedTerm hydraVersion)},+        Core.Field {+          Core.fieldName = (Core.Name "revision"),+          Core.fieldTerm = (Typed.unTypedTerm revision)},+        Core.Field {+          Core.fieldName = (Core.Name "timestamp"),+          Core.fieldTerm = (Typed.unTypedTerm timestamp)}]}))++-- | DSL name token for hydra.build.format.Generation+generationGeneration :: Typed.TypedName Format.Generation+generationGeneration = Typed.TypedName (Core.Name "hydra.build.format.Generation")++-- | DSL accessor for the generatorId field of hydra.build.format.Generation+generationGeneratorId :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm String+generationGeneratorId x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+        Core.projectionFieldName = (Core.Name "generatorId")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the host field of hydra.build.format.Generation+generationHost :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm Format.LanguageName+generationHost x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+        Core.projectionFieldName = (Core.Name "host")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the hydraVersion field of hydra.build.format.Generation+generationHydraVersion :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm (Maybe Packaging.Version)+generationHydraVersion x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+        Core.projectionFieldName = (Core.Name "hydraVersion")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the mode field of hydra.build.format.Generation+generationMode :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm Format.GenerationMode+generationMode x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+        Core.projectionFieldName = (Core.Name "mode")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.format.GenerationMode+generationModeGenerationMode :: Typed.TypedName Format.GenerationMode+generationModeGenerationMode = Typed.TypedName (Core.Name "hydra.build.format.GenerationMode")++-- | DSL injection for the published variant of hydra.build.format.GenerationMode+generationModePublished :: Typed.TypedTerm Format.GenerationMode+generationModePublished =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.build.format.GenerationMode"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "published"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the shim variant of hydra.build.format.GenerationMode+generationModeShim :: Typed.TypedTerm Format.GenerationMode+generationModeShim =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.build.format.GenerationMode"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "shim"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL accessor for the revision field of hydra.build.format.Generation+generationRevision :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm (Maybe String)+generationRevision x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+        Core.projectionFieldName = (Core.Name "revision")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the timestamp field of hydra.build.format.Generation+generationTimestamp :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm (Maybe String)+generationTimestamp x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+        Core.projectionFieldName = (Core.Name "timestamp")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the generatorId field of hydra.build.format.Generation+generationWithGeneratorId :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm String -> Typed.TypedTerm Format.Generation+generationWithGeneratorId original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.Generation"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "generatorId"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "mode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+              Core.projectionFieldName = (Core.Name "mode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "host"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+              Core.projectionFieldName = (Core.Name "host")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "hydraVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+              Core.projectionFieldName = (Core.Name "hydraVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "revision"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+              Core.projectionFieldName = (Core.Name "revision")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "timestamp"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+              Core.projectionFieldName = (Core.Name "timestamp")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the host field of hydra.build.format.Generation+generationWithHost :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm Format.LanguageName -> Typed.TypedTerm Format.Generation+generationWithHost original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.Generation"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "generatorId"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+              Core.projectionFieldName = (Core.Name "generatorId")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "mode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+              Core.projectionFieldName = (Core.Name "mode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "host"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "hydraVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+              Core.projectionFieldName = (Core.Name "hydraVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "revision"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+              Core.projectionFieldName = (Core.Name "revision")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "timestamp"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+              Core.projectionFieldName = (Core.Name "timestamp")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the hydraVersion field of hydra.build.format.Generation+generationWithHydraVersion :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm (Maybe Packaging.Version) -> Typed.TypedTerm Format.Generation+generationWithHydraVersion original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.Generation"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "generatorId"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+              Core.projectionFieldName = (Core.Name "generatorId")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "mode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+              Core.projectionFieldName = (Core.Name "mode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "host"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+              Core.projectionFieldName = (Core.Name "host")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "hydraVersion"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "revision"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+              Core.projectionFieldName = (Core.Name "revision")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "timestamp"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+              Core.projectionFieldName = (Core.Name "timestamp")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the mode field of hydra.build.format.Generation+generationWithMode :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm Format.GenerationMode -> Typed.TypedTerm Format.Generation+generationWithMode original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.Generation"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "generatorId"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+              Core.projectionFieldName = (Core.Name "generatorId")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "mode"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "host"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+              Core.projectionFieldName = (Core.Name "host")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "hydraVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+              Core.projectionFieldName = (Core.Name "hydraVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "revision"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+              Core.projectionFieldName = (Core.Name "revision")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "timestamp"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+              Core.projectionFieldName = (Core.Name "timestamp")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the revision field of hydra.build.format.Generation+generationWithRevision :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Format.Generation+generationWithRevision original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.Generation"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "generatorId"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+              Core.projectionFieldName = (Core.Name "generatorId")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "mode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+              Core.projectionFieldName = (Core.Name "mode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "host"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+              Core.projectionFieldName = (Core.Name "host")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "hydraVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+              Core.projectionFieldName = (Core.Name "hydraVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "revision"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "timestamp"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+              Core.projectionFieldName = (Core.Name "timestamp")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the timestamp field of hydra.build.format.Generation+generationWithTimestamp :: Typed.TypedTerm Format.Generation -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Format.Generation+generationWithTimestamp original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.Generation"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "generatorId"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+              Core.projectionFieldName = (Core.Name "generatorId")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "mode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+              Core.projectionFieldName = (Core.Name "mode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "host"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+              Core.projectionFieldName = (Core.Name "host")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "hydraVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+              Core.projectionFieldName = (Core.Name "hydraVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "revision"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.Generation"),+              Core.projectionFieldName = (Core.Name "revision")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "timestamp"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL name token for hydra.build.format.HostOverride+hostOverrideHostOverride :: Typed.TypedName Format.HostOverride+hostOverrideHostOverride = Typed.TypedName (Core.Name "hydra.build.format.HostOverride")++-- | DSL injection for the local variant of hydra.build.format.HostOverride+hostOverrideLocal :: Typed.TypedTerm Format.HostOverride+hostOverrideLocal =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.build.format.HostOverride"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "local"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL injection for the version variant of hydra.build.format.HostOverride+hostOverrideVersion :: Typed.TypedTerm Packaging.Version -> Typed.TypedTerm Format.HostOverride+hostOverrideVersion x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.build.format.HostOverride"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "version"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))++-- | DSL constructor for hydra.build.format.InputDigest+inputDigest :: Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm (Maybe Format.Sha256Hash) -> Typed.TypedTerm (M.Map Packaging.PackageName Format.Sha256Hash) -> Typed.TypedTerm (M.Map Packaging.ModuleName Format.Sha256Hash) -> Typed.TypedTerm Format.InputDigest+inputDigest digestFormatVersion moduleFormatVersion selfHash dependencyHashes moduleHashes =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.InputDigest"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "digestFormatVersion"),+          Core.fieldTerm = (Typed.unTypedTerm digestFormatVersion)},+        Core.Field {+          Core.fieldName = (Core.Name "moduleFormatVersion"),+          Core.fieldTerm = (Typed.unTypedTerm moduleFormatVersion)},+        Core.Field {+          Core.fieldName = (Core.Name "selfHash"),+          Core.fieldTerm = (Typed.unTypedTerm selfHash)},+        Core.Field {+          Core.fieldName = (Core.Name "dependencyHashes"),+          Core.fieldTerm = (Typed.unTypedTerm dependencyHashes)},+        Core.Field {+          Core.fieldName = (Core.Name "moduleHashes"),+          Core.fieldTerm = (Typed.unTypedTerm moduleHashes)}]}))++-- | DSL accessor for the dependencyHashes field of hydra.build.format.InputDigest+inputDigestDependencyHashes :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm (M.Map Packaging.PackageName Format.Sha256Hash)+inputDigestDependencyHashes x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),+        Core.projectionFieldName = (Core.Name "dependencyHashes")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the digestFormatVersion field of hydra.build.format.InputDigest+inputDigestDigestFormatVersion :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm Int+inputDigestDigestFormatVersion x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),+        Core.projectionFieldName = (Core.Name "digestFormatVersion")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.format.InputDigest+inputDigestInputDigest :: Typed.TypedName Format.InputDigest+inputDigestInputDigest = Typed.TypedName (Core.Name "hydra.build.format.InputDigest")++-- | DSL accessor for the moduleFormatVersion field of hydra.build.format.InputDigest+inputDigestModuleFormatVersion :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm Int+inputDigestModuleFormatVersion x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),+        Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the moduleHashes field of hydra.build.format.InputDigest+inputDigestModuleHashes :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm (M.Map Packaging.ModuleName Format.Sha256Hash)+inputDigestModuleHashes x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),+        Core.projectionFieldName = (Core.Name "moduleHashes")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the selfHash field of hydra.build.format.InputDigest+inputDigestSelfHash :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm (Maybe Format.Sha256Hash)+inputDigestSelfHash x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),+        Core.projectionFieldName = (Core.Name "selfHash")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the dependencyHashes field of hydra.build.format.InputDigest+inputDigestWithDependencyHashes :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm (M.Map Packaging.PackageName Format.Sha256Hash) -> Typed.TypedTerm Format.InputDigest+inputDigestWithDependencyHashes original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.InputDigest"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "digestFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),+              Core.projectionFieldName = (Core.Name "digestFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "moduleFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),+              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "selfHash"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),+              Core.projectionFieldName = (Core.Name "selfHash")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "dependencyHashes"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "moduleHashes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),+              Core.projectionFieldName = (Core.Name "moduleHashes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the digestFormatVersion field of hydra.build.format.InputDigest+inputDigestWithDigestFormatVersion :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm Int -> Typed.TypedTerm Format.InputDigest+inputDigestWithDigestFormatVersion original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.InputDigest"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "digestFormatVersion"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "moduleFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),+              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "selfHash"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),+              Core.projectionFieldName = (Core.Name "selfHash")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "dependencyHashes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),+              Core.projectionFieldName = (Core.Name "dependencyHashes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "moduleHashes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),+              Core.projectionFieldName = (Core.Name "moduleHashes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the moduleFormatVersion field of hydra.build.format.InputDigest+inputDigestWithModuleFormatVersion :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm Int -> Typed.TypedTerm Format.InputDigest+inputDigestWithModuleFormatVersion original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.InputDigest"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "digestFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),+              Core.projectionFieldName = (Core.Name "digestFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "moduleFormatVersion"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "selfHash"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),+              Core.projectionFieldName = (Core.Name "selfHash")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "dependencyHashes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),+              Core.projectionFieldName = (Core.Name "dependencyHashes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "moduleHashes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),+              Core.projectionFieldName = (Core.Name "moduleHashes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the moduleHashes field of hydra.build.format.InputDigest+inputDigestWithModuleHashes :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm (M.Map Packaging.ModuleName Format.Sha256Hash) -> Typed.TypedTerm Format.InputDigest+inputDigestWithModuleHashes original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.InputDigest"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "digestFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),+              Core.projectionFieldName = (Core.Name "digestFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "moduleFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),+              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "selfHash"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),+              Core.projectionFieldName = (Core.Name "selfHash")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "dependencyHashes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),+              Core.projectionFieldName = (Core.Name "dependencyHashes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "moduleHashes"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the selfHash field of hydra.build.format.InputDigest+inputDigestWithSelfHash :: Typed.TypedTerm Format.InputDigest -> Typed.TypedTerm (Maybe Format.Sha256Hash) -> Typed.TypedTerm Format.InputDigest+inputDigestWithSelfHash original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.InputDigest"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "digestFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),+              Core.projectionFieldName = (Core.Name "digestFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "moduleFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),+              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "selfHash"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "dependencyHashes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),+              Core.projectionFieldName = (Core.Name "dependencyHashes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "moduleHashes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.InputDigest"),+              Core.projectionFieldName = (Core.Name "moduleHashes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for the hydra.build.format.LanguageName wrapper+languageName :: Typed.TypedTerm String -> Typed.TypedTerm Format.LanguageName+languageName x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.build.format.LanguageName"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.format.LanguageName+languageNameLanguageName :: Typed.TypedName Format.LanguageName+languageNameLanguageName = Typed.TypedName (Core.Name "hydra.build.format.LanguageName")++-- | DSL constructor for hydra.build.format.ModuleValidationProfile+moduleValidationProfile :: Typed.TypedTerm (Maybe Format.DefinitionValidationProfile) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.ModuleValidationProfile+moduleValidationProfile definitions nameConvention conflictingVariantName =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "definitions"),+          Core.fieldTerm = (Typed.unTypedTerm definitions)},+        Core.Field {+          Core.fieldName = (Core.Name "nameConvention"),+          Core.fieldTerm = (Typed.unTypedTerm nameConvention)},+        Core.Field {+          Core.fieldName = (Core.Name "conflictingVariantName"),+          Core.fieldTerm = (Typed.unTypedTerm conflictingVariantName)}]}))++-- | DSL accessor for the conflictingVariantName field of hydra.build.format.ModuleValidationProfile+moduleValidationProfileConflictingVariantName :: Typed.TypedTerm Format.ModuleValidationProfile -> Typed.TypedTerm (Maybe Format.Severity)+moduleValidationProfileConflictingVariantName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"),+        Core.projectionFieldName = (Core.Name "conflictingVariantName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the definitions field of hydra.build.format.ModuleValidationProfile+moduleValidationProfileDefinitions :: Typed.TypedTerm Format.ModuleValidationProfile -> Typed.TypedTerm (Maybe Format.DefinitionValidationProfile)+moduleValidationProfileDefinitions x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"),+        Core.projectionFieldName = (Core.Name "definitions")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.format.ModuleValidationProfile+moduleValidationProfileModuleValidationProfile :: Typed.TypedName Format.ModuleValidationProfile+moduleValidationProfileModuleValidationProfile = Typed.TypedName (Core.Name "hydra.build.format.ModuleValidationProfile")++-- | DSL accessor for the nameConvention field of hydra.build.format.ModuleValidationProfile+moduleValidationProfileNameConvention :: Typed.TypedTerm Format.ModuleValidationProfile -> Typed.TypedTerm (Maybe Format.Severity)+moduleValidationProfileNameConvention x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"),+        Core.projectionFieldName = (Core.Name "nameConvention")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the conflictingVariantName field of hydra.build.format.ModuleValidationProfile+moduleValidationProfileWithConflictingVariantName :: Typed.TypedTerm Format.ModuleValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.ModuleValidationProfile+moduleValidationProfileWithConflictingVariantName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "definitions"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"),+              Core.projectionFieldName = (Core.Name "definitions")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "nameConvention"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"),+              Core.projectionFieldName = (Core.Name "nameConvention")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "conflictingVariantName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the definitions field of hydra.build.format.ModuleValidationProfile+moduleValidationProfileWithDefinitions :: Typed.TypedTerm Format.ModuleValidationProfile -> Typed.TypedTerm (Maybe Format.DefinitionValidationProfile) -> Typed.TypedTerm Format.ModuleValidationProfile+moduleValidationProfileWithDefinitions original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "definitions"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "nameConvention"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"),+              Core.projectionFieldName = (Core.Name "nameConvention")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "conflictingVariantName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"),+              Core.projectionFieldName = (Core.Name "conflictingVariantName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the nameConvention field of hydra.build.format.ModuleValidationProfile+moduleValidationProfileWithNameConvention :: Typed.TypedTerm Format.ModuleValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.ModuleValidationProfile+moduleValidationProfileWithNameConvention original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "definitions"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"),+              Core.projectionFieldName = (Core.Name "definitions")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "nameConvention"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "conflictingVariantName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"),+              Core.projectionFieldName = (Core.Name "conflictingVariantName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.build.format.OutputDigest+outputDigest :: Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm String -> Typed.TypedTerm Format.Generation -> Typed.TypedTerm (Maybe Format.Sha256Hash) -> Typed.TypedTerm (M.Map Packaging.PackageName Format.Sha256Hash) -> Typed.TypedTerm (M.Map String Format.DigestEntry) -> Typed.TypedTerm (M.Map String Format.DigestEntry) -> Typed.TypedTerm Format.OutputDigest+outputDigest digestFormatVersion moduleFormatVersion generator generation selfHash dependencyHashes inputs outputs =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.OutputDigest"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "digestFormatVersion"),+          Core.fieldTerm = (Typed.unTypedTerm digestFormatVersion)},+        Core.Field {+          Core.fieldName = (Core.Name "moduleFormatVersion"),+          Core.fieldTerm = (Typed.unTypedTerm moduleFormatVersion)},+        Core.Field {+          Core.fieldName = (Core.Name "generator"),+          Core.fieldTerm = (Typed.unTypedTerm generator)},+        Core.Field {+          Core.fieldName = (Core.Name "generation"),+          Core.fieldTerm = (Typed.unTypedTerm generation)},+        Core.Field {+          Core.fieldName = (Core.Name "selfHash"),+          Core.fieldTerm = (Typed.unTypedTerm selfHash)},+        Core.Field {+          Core.fieldName = (Core.Name "dependencyHashes"),+          Core.fieldTerm = (Typed.unTypedTerm dependencyHashes)},+        Core.Field {+          Core.fieldName = (Core.Name "inputs"),+          Core.fieldTerm = (Typed.unTypedTerm inputs)},+        Core.Field {+          Core.fieldName = (Core.Name "outputs"),+          Core.fieldTerm = (Typed.unTypedTerm outputs)}]}))++-- | DSL accessor for the dependencyHashes field of hydra.build.format.OutputDigest+outputDigestDependencyHashes :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (M.Map Packaging.PackageName Format.Sha256Hash)+outputDigestDependencyHashes x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+        Core.projectionFieldName = (Core.Name "dependencyHashes")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the digestFormatVersion field of hydra.build.format.OutputDigest+outputDigestDigestFormatVersion :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm Int+outputDigestDigestFormatVersion x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+        Core.projectionFieldName = (Core.Name "digestFormatVersion")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the generation field of hydra.build.format.OutputDigest+outputDigestGeneration :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm Format.Generation+outputDigestGeneration x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+        Core.projectionFieldName = (Core.Name "generation")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the generator field of hydra.build.format.OutputDigest+outputDigestGenerator :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm String+outputDigestGenerator x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+        Core.projectionFieldName = (Core.Name "generator")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the inputs field of hydra.build.format.OutputDigest+outputDigestInputs :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (M.Map String Format.DigestEntry)+outputDigestInputs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+        Core.projectionFieldName = (Core.Name "inputs")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the moduleFormatVersion field of hydra.build.format.OutputDigest+outputDigestModuleFormatVersion :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm Int+outputDigestModuleFormatVersion x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+        Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.format.OutputDigest+outputDigestOutputDigest :: Typed.TypedName Format.OutputDigest+outputDigestOutputDigest = Typed.TypedName (Core.Name "hydra.build.format.OutputDigest")++-- | DSL accessor for the outputs field of hydra.build.format.OutputDigest+outputDigestOutputs :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (M.Map String Format.DigestEntry)+outputDigestOutputs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+        Core.projectionFieldName = (Core.Name "outputs")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the selfHash field of hydra.build.format.OutputDigest+outputDigestSelfHash :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (Maybe Format.Sha256Hash)+outputDigestSelfHash x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+        Core.projectionFieldName = (Core.Name "selfHash")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the dependencyHashes field of hydra.build.format.OutputDigest+outputDigestWithDependencyHashes :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (M.Map Packaging.PackageName Format.Sha256Hash) -> Typed.TypedTerm Format.OutputDigest+outputDigestWithDependencyHashes original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.OutputDigest"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "digestFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "digestFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "moduleFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "generator"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "generator")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "generation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "generation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "selfHash"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "selfHash")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "dependencyHashes"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "inputs"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "inputs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "outputs"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "outputs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the digestFormatVersion field of hydra.build.format.OutputDigest+outputDigestWithDigestFormatVersion :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm Int -> Typed.TypedTerm Format.OutputDigest+outputDigestWithDigestFormatVersion original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.OutputDigest"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "digestFormatVersion"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "moduleFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "generator"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "generator")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "generation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "generation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "selfHash"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "selfHash")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "dependencyHashes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "dependencyHashes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "inputs"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "inputs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "outputs"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "outputs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the generation field of hydra.build.format.OutputDigest+outputDigestWithGeneration :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm Format.Generation -> Typed.TypedTerm Format.OutputDigest+outputDigestWithGeneration original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.OutputDigest"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "digestFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "digestFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "moduleFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "generator"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "generator")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "generation"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "selfHash"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "selfHash")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "dependencyHashes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "dependencyHashes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "inputs"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "inputs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "outputs"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "outputs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the generator field of hydra.build.format.OutputDigest+outputDigestWithGenerator :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm String -> Typed.TypedTerm Format.OutputDigest+outputDigestWithGenerator original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.OutputDigest"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "digestFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "digestFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "moduleFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "generator"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "generation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "generation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "selfHash"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "selfHash")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "dependencyHashes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "dependencyHashes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "inputs"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "inputs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "outputs"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "outputs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the inputs field of hydra.build.format.OutputDigest+outputDigestWithInputs :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (M.Map String Format.DigestEntry) -> Typed.TypedTerm Format.OutputDigest+outputDigestWithInputs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.OutputDigest"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "digestFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "digestFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "moduleFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "generator"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "generator")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "generation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "generation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "selfHash"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "selfHash")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "dependencyHashes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "dependencyHashes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "inputs"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "outputs"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "outputs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the moduleFormatVersion field of hydra.build.format.OutputDigest+outputDigestWithModuleFormatVersion :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm Int -> Typed.TypedTerm Format.OutputDigest+outputDigestWithModuleFormatVersion original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.OutputDigest"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "digestFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "digestFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "moduleFormatVersion"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "generator"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "generator")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "generation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "generation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "selfHash"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "selfHash")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "dependencyHashes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "dependencyHashes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "inputs"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "inputs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "outputs"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "outputs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the outputs field of hydra.build.format.OutputDigest+outputDigestWithOutputs :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (M.Map String Format.DigestEntry) -> Typed.TypedTerm Format.OutputDigest+outputDigestWithOutputs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.OutputDigest"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "digestFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "digestFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "moduleFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "generator"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "generator")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "generation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "generation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "selfHash"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "selfHash")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "dependencyHashes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "dependencyHashes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "inputs"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "inputs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "outputs"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the selfHash field of hydra.build.format.OutputDigest+outputDigestWithSelfHash :: Typed.TypedTerm Format.OutputDigest -> Typed.TypedTerm (Maybe Format.Sha256Hash) -> Typed.TypedTerm Format.OutputDigest+outputDigestWithSelfHash original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.OutputDigest"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "digestFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "digestFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "moduleFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "generator"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "generator")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "generation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "generation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "selfHash"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "dependencyHashes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "dependencyHashes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "inputs"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "inputs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "outputs"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.OutputDigest"),+              Core.projectionFieldName = (Core.Name "outputs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.build.format.PackageDescriptor+packageDescriptor :: Typed.TypedTerm Int -> Typed.TypedTerm Packaging.PackageName -> Typed.TypedTerm String -> Typed.TypedTerm Format.LanguageName -> Typed.TypedTerm (Maybe [Format.LanguageName]) -> Typed.TypedTerm [Packaging.PackageName] -> Typed.TypedTerm (Maybe Format.PackageValidationConfiguration) -> Typed.TypedTerm Format.PackageDescriptor+packageDescriptor packageFormatVersion name description sourceLanguage targetLanguages dependencies validation =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "packageFormatVersion"),+          Core.fieldTerm = (Typed.unTypedTerm packageFormatVersion)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Typed.unTypedTerm description)},+        Core.Field {+          Core.fieldName = (Core.Name "sourceLanguage"),+          Core.fieldTerm = (Typed.unTypedTerm sourceLanguage)},+        Core.Field {+          Core.fieldName = (Core.Name "targetLanguages"),+          Core.fieldTerm = (Typed.unTypedTerm targetLanguages)},+        Core.Field {+          Core.fieldName = (Core.Name "dependencies"),+          Core.fieldTerm = (Typed.unTypedTerm dependencies)},+        Core.Field {+          Core.fieldName = (Core.Name "validation"),+          Core.fieldTerm = (Typed.unTypedTerm validation)}]}))++-- | DSL accessor for the dependencies field of hydra.build.format.PackageDescriptor+packageDescriptorDependencies :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm [Packaging.PackageName]+packageDescriptorDependencies x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+        Core.projectionFieldName = (Core.Name "dependencies")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the description field of hydra.build.format.PackageDescriptor+packageDescriptorDescription :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm String+packageDescriptorDescription x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+        Core.projectionFieldName = (Core.Name "description")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the name field of hydra.build.format.PackageDescriptor+packageDescriptorName :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm Packaging.PackageName+packageDescriptorName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.format.PackageDescriptor+packageDescriptorPackageDescriptor :: Typed.TypedName Format.PackageDescriptor+packageDescriptorPackageDescriptor = Typed.TypedName (Core.Name "hydra.build.format.PackageDescriptor")++-- | DSL accessor for the packageFormatVersion field of hydra.build.format.PackageDescriptor+packageDescriptorPackageFormatVersion :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm Int+packageDescriptorPackageFormatVersion x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+        Core.projectionFieldName = (Core.Name "packageFormatVersion")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the sourceLanguage field of hydra.build.format.PackageDescriptor+packageDescriptorSourceLanguage :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm Format.LanguageName+packageDescriptorSourceLanguage x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+        Core.projectionFieldName = (Core.Name "sourceLanguage")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the targetLanguages field of hydra.build.format.PackageDescriptor+packageDescriptorTargetLanguages :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm (Maybe [Format.LanguageName])+packageDescriptorTargetLanguages x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+        Core.projectionFieldName = (Core.Name "targetLanguages")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the validation field of hydra.build.format.PackageDescriptor+packageDescriptorValidation :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm (Maybe Format.PackageValidationConfiguration)+packageDescriptorValidation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+        Core.projectionFieldName = (Core.Name "validation")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the dependencies field of hydra.build.format.PackageDescriptor+packageDescriptorWithDependencies :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm [Packaging.PackageName] -> Typed.TypedTerm Format.PackageDescriptor+packageDescriptorWithDependencies original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "packageFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "packageFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "description")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "sourceLanguage"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "sourceLanguage")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetLanguages"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "targetLanguages")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "dependencies"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "validation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "validation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the description field of hydra.build.format.PackageDescriptor+packageDescriptorWithDescription :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm String -> Typed.TypedTerm Format.PackageDescriptor+packageDescriptorWithDescription original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "packageFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "packageFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "sourceLanguage"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "sourceLanguage")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetLanguages"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "targetLanguages")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "dependencies"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "dependencies")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "validation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "validation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the name field of hydra.build.format.PackageDescriptor+packageDescriptorWithName :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm Packaging.PackageName -> Typed.TypedTerm Format.PackageDescriptor+packageDescriptorWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "packageFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "packageFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "description")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "sourceLanguage"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "sourceLanguage")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetLanguages"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "targetLanguages")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "dependencies"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "dependencies")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "validation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "validation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the packageFormatVersion field of hydra.build.format.PackageDescriptor+packageDescriptorWithPackageFormatVersion :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm Int -> Typed.TypedTerm Format.PackageDescriptor+packageDescriptorWithPackageFormatVersion original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "packageFormatVersion"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "description")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "sourceLanguage"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "sourceLanguage")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetLanguages"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "targetLanguages")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "dependencies"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "dependencies")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "validation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "validation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the sourceLanguage field of hydra.build.format.PackageDescriptor+packageDescriptorWithSourceLanguage :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm Format.LanguageName -> Typed.TypedTerm Format.PackageDescriptor+packageDescriptorWithSourceLanguage original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "packageFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "packageFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "description")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "sourceLanguage"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "targetLanguages"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "targetLanguages")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "dependencies"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "dependencies")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "validation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "validation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the targetLanguages field of hydra.build.format.PackageDescriptor+packageDescriptorWithTargetLanguages :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm (Maybe [Format.LanguageName]) -> Typed.TypedTerm Format.PackageDescriptor+packageDescriptorWithTargetLanguages original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "packageFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "packageFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "description")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "sourceLanguage"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "sourceLanguage")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetLanguages"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "dependencies"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "dependencies")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "validation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "validation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the validation field of hydra.build.format.PackageDescriptor+packageDescriptorWithValidation :: Typed.TypedTerm Format.PackageDescriptor -> Typed.TypedTerm (Maybe Format.PackageValidationConfiguration) -> Typed.TypedTerm Format.PackageDescriptor+packageDescriptorWithValidation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "packageFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "packageFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "description")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "sourceLanguage"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "sourceLanguage")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "targetLanguages"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "targetLanguages")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "dependencies"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+              Core.projectionFieldName = (Core.Name "dependencies")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "validation"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.build.format.PackageManifest+packageManifest :: Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm Packaging.PackageName -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm Format.PackageManifest+packageManifest manifestFormatVersion moduleFormatVersion package mainModules testModules mainDslModules mainEncodingModules =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.PackageManifest"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "manifestFormatVersion"),+          Core.fieldTerm = (Typed.unTypedTerm manifestFormatVersion)},+        Core.Field {+          Core.fieldName = (Core.Name "moduleFormatVersion"),+          Core.fieldTerm = (Typed.unTypedTerm moduleFormatVersion)},+        Core.Field {+          Core.fieldName = (Core.Name "package"),+          Core.fieldTerm = (Typed.unTypedTerm package)},+        Core.Field {+          Core.fieldName = (Core.Name "mainModules"),+          Core.fieldTerm = (Typed.unTypedTerm mainModules)},+        Core.Field {+          Core.fieldName = (Core.Name "testModules"),+          Core.fieldTerm = (Typed.unTypedTerm testModules)},+        Core.Field {+          Core.fieldName = (Core.Name "mainDslModules"),+          Core.fieldTerm = (Typed.unTypedTerm mainDslModules)},+        Core.Field {+          Core.fieldName = (Core.Name "mainEncodingModules"),+          Core.fieldTerm = (Typed.unTypedTerm mainEncodingModules)}]}))++-- | DSL accessor for the mainDslModules field of hydra.build.format.PackageManifest+packageManifestMainDslModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName]+packageManifestMainDslModules x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+        Core.projectionFieldName = (Core.Name "mainDslModules")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the mainEncodingModules field of hydra.build.format.PackageManifest+packageManifestMainEncodingModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName]+packageManifestMainEncodingModules x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+        Core.projectionFieldName = (Core.Name "mainEncodingModules")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the mainModules field of hydra.build.format.PackageManifest+packageManifestMainModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName]+packageManifestMainModules x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+        Core.projectionFieldName = (Core.Name "mainModules")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the manifestFormatVersion field of hydra.build.format.PackageManifest+packageManifestManifestFormatVersion :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm Int+packageManifestManifestFormatVersion x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+        Core.projectionFieldName = (Core.Name "manifestFormatVersion")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the moduleFormatVersion field of hydra.build.format.PackageManifest+packageManifestModuleFormatVersion :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm Int+packageManifestModuleFormatVersion x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+        Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the package field of hydra.build.format.PackageManifest+packageManifestPackage :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm Packaging.PackageName+packageManifestPackage x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+        Core.projectionFieldName = (Core.Name "package")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.format.PackageManifest+packageManifestPackageManifest :: Typed.TypedName Format.PackageManifest+packageManifestPackageManifest = Typed.TypedName (Core.Name "hydra.build.format.PackageManifest")++-- | DSL accessor for the testModules field of hydra.build.format.PackageManifest+packageManifestTestModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName]+packageManifestTestModules x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+        Core.projectionFieldName = (Core.Name "testModules")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the mainDslModules field of hydra.build.format.PackageManifest+packageManifestWithMainDslModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm Format.PackageManifest+packageManifestWithMainDslModules original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.PackageManifest"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "manifestFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "manifestFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "moduleFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "package"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "package")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "mainModules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "mainModules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "testModules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "testModules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "mainDslModules"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "mainEncodingModules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "mainEncodingModules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the mainEncodingModules field of hydra.build.format.PackageManifest+packageManifestWithMainEncodingModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm Format.PackageManifest+packageManifestWithMainEncodingModules original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.PackageManifest"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "manifestFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "manifestFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "moduleFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "package"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "package")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "mainModules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "mainModules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "testModules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "testModules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "mainDslModules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "mainDslModules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "mainEncodingModules"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the mainModules field of hydra.build.format.PackageManifest+packageManifestWithMainModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm Format.PackageManifest+packageManifestWithMainModules original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.PackageManifest"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "manifestFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "manifestFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "moduleFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "package"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "package")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "mainModules"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "testModules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "testModules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "mainDslModules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "mainDslModules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "mainEncodingModules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "mainEncodingModules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the manifestFormatVersion field of hydra.build.format.PackageManifest+packageManifestWithManifestFormatVersion :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm Int -> Typed.TypedTerm Format.PackageManifest+packageManifestWithManifestFormatVersion original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.PackageManifest"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "manifestFormatVersion"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "moduleFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "package"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "package")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "mainModules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "mainModules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "testModules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "testModules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "mainDslModules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "mainDslModules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "mainEncodingModules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "mainEncodingModules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the moduleFormatVersion field of hydra.build.format.PackageManifest+packageManifestWithModuleFormatVersion :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm Int -> Typed.TypedTerm Format.PackageManifest+packageManifestWithModuleFormatVersion original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.PackageManifest"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "manifestFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "manifestFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "moduleFormatVersion"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "package"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "package")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "mainModules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "mainModules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "testModules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "testModules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "mainDslModules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "mainDslModules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "mainEncodingModules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "mainEncodingModules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the package field of hydra.build.format.PackageManifest+packageManifestWithPackage :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm Packaging.PackageName -> Typed.TypedTerm Format.PackageManifest+packageManifestWithPackage original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.PackageManifest"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "manifestFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "manifestFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "moduleFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "package"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "mainModules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "mainModules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "testModules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "testModules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "mainDslModules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "mainDslModules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "mainEncodingModules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "mainEncodingModules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the testModules field of hydra.build.format.PackageManifest+packageManifestWithTestModules :: Typed.TypedTerm Format.PackageManifest -> Typed.TypedTerm [Packaging.ModuleName] -> Typed.TypedTerm Format.PackageManifest+packageManifestWithTestModules original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.PackageManifest"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "manifestFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "manifestFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "moduleFormatVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "moduleFormatVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "package"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "package")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "mainModules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "mainModules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "testModules"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "mainDslModules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "mainDslModules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "mainEncodingModules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageManifest"),+              Core.projectionFieldName = (Core.Name "mainEncodingModules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.build.format.PackageValidationConfiguration+packageValidationConfiguration :: Typed.TypedTerm (Maybe Format.PackageValidationProfile) -> Typed.TypedTerm (Maybe Format.ModuleValidationProfile) -> Typed.TypedTerm (Maybe Format.TypeValidationProfile) -> Typed.TypedTerm (Maybe Format.TermValidationProfile) -> Typed.TypedTerm Format.PackageValidationConfiguration+packageValidationConfiguration package module_ type_ term =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "package"),+          Core.fieldTerm = (Typed.unTypedTerm package)},+        Core.Field {+          Core.fieldName = (Core.Name "module"),+          Core.fieldTerm = (Typed.unTypedTerm module_)},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm type_)},+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Typed.unTypedTerm term)}]}))++-- | DSL accessor for the module field of hydra.build.format.PackageValidationConfiguration+packageValidationConfigurationModule :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.ModuleValidationProfile)+packageValidationConfigurationModule x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),+        Core.projectionFieldName = (Core.Name "module")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the package field of hydra.build.format.PackageValidationConfiguration+packageValidationConfigurationPackage :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.PackageValidationProfile)+packageValidationConfigurationPackage x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),+        Core.projectionFieldName = (Core.Name "package")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.format.PackageValidationConfiguration+packageValidationConfigurationPackageValidationConfiguration :: Typed.TypedName Format.PackageValidationConfiguration+packageValidationConfigurationPackageValidationConfiguration =+    Typed.TypedName (Core.Name "hydra.build.format.PackageValidationConfiguration")++-- | DSL accessor for the term field of hydra.build.format.PackageValidationConfiguration+packageValidationConfigurationTerm :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.TermValidationProfile)+packageValidationConfigurationTerm x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),+        Core.projectionFieldName = (Core.Name "term")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the type field of hydra.build.format.PackageValidationConfiguration+packageValidationConfigurationType :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.TypeValidationProfile)+packageValidationConfigurationType x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),+        Core.projectionFieldName = (Core.Name "type")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the module field of hydra.build.format.PackageValidationConfiguration+packageValidationConfigurationWithModule :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.ModuleValidationProfile) -> Typed.TypedTerm Format.PackageValidationConfiguration+packageValidationConfigurationWithModule original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "package"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),+              Core.projectionFieldName = (Core.Name "package")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "module"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),+              Core.projectionFieldName = (Core.Name "term")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the package field of hydra.build.format.PackageValidationConfiguration+packageValidationConfigurationWithPackage :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.PackageValidationProfile) -> Typed.TypedTerm Format.PackageValidationConfiguration+packageValidationConfigurationWithPackage original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "package"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "module"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),+              Core.projectionFieldName = (Core.Name "module")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),+              Core.projectionFieldName = (Core.Name "term")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the term field of hydra.build.format.PackageValidationConfiguration+packageValidationConfigurationWithTerm :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.TermValidationProfile) -> Typed.TypedTerm Format.PackageValidationConfiguration+packageValidationConfigurationWithTerm original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "package"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),+              Core.projectionFieldName = (Core.Name "package")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "module"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),+              Core.projectionFieldName = (Core.Name "module")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the type field of hydra.build.format.PackageValidationConfiguration+packageValidationConfigurationWithType :: Typed.TypedTerm Format.PackageValidationConfiguration -> Typed.TypedTerm (Maybe Format.TypeValidationProfile) -> Typed.TypedTerm Format.PackageValidationConfiguration+packageValidationConfigurationWithType original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "package"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),+              Core.projectionFieldName = (Core.Name "package")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "module"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),+              Core.projectionFieldName = (Core.Name "module")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),+              Core.projectionFieldName = (Core.Name "term")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL constructor for hydra.build.format.PackageValidationProfile+packageValidationProfile :: Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.PackageValidationProfile+packageValidationProfile conflictingModuleName duplicateModuleName nameConvention =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "conflictingModuleName"),+          Core.fieldTerm = (Typed.unTypedTerm conflictingModuleName)},+        Core.Field {+          Core.fieldName = (Core.Name "duplicateModuleName"),+          Core.fieldTerm = (Typed.unTypedTerm duplicateModuleName)},+        Core.Field {+          Core.fieldName = (Core.Name "nameConvention"),+          Core.fieldTerm = (Typed.unTypedTerm nameConvention)}]}))++-- | DSL accessor for the conflictingModuleName field of hydra.build.format.PackageValidationProfile+packageValidationProfileConflictingModuleName :: Typed.TypedTerm Format.PackageValidationProfile -> Typed.TypedTerm (Maybe Format.Severity)+packageValidationProfileConflictingModuleName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"),+        Core.projectionFieldName = (Core.Name "conflictingModuleName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the duplicateModuleName field of hydra.build.format.PackageValidationProfile+packageValidationProfileDuplicateModuleName :: Typed.TypedTerm Format.PackageValidationProfile -> Typed.TypedTerm (Maybe Format.Severity)+packageValidationProfileDuplicateModuleName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"),+        Core.projectionFieldName = (Core.Name "duplicateModuleName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the nameConvention field of hydra.build.format.PackageValidationProfile+packageValidationProfileNameConvention :: Typed.TypedTerm Format.PackageValidationProfile -> Typed.TypedTerm (Maybe Format.Severity)+packageValidationProfileNameConvention x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"),+        Core.projectionFieldName = (Core.Name "nameConvention")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.format.PackageValidationProfile+packageValidationProfilePackageValidationProfile :: Typed.TypedName Format.PackageValidationProfile+packageValidationProfilePackageValidationProfile =+    Typed.TypedName (Core.Name "hydra.build.format.PackageValidationProfile")++-- | DSL updater for the conflictingModuleName field of hydra.build.format.PackageValidationProfile+packageValidationProfileWithConflictingModuleName :: Typed.TypedTerm Format.PackageValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.PackageValidationProfile+packageValidationProfileWithConflictingModuleName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "conflictingModuleName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "duplicateModuleName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"),+              Core.projectionFieldName = (Core.Name "duplicateModuleName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "nameConvention"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"),+              Core.projectionFieldName = (Core.Name "nameConvention")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the duplicateModuleName field of hydra.build.format.PackageValidationProfile+packageValidationProfileWithDuplicateModuleName :: Typed.TypedTerm Format.PackageValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.PackageValidationProfile+packageValidationProfileWithDuplicateModuleName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "conflictingModuleName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"),+              Core.projectionFieldName = (Core.Name "conflictingModuleName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "duplicateModuleName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "nameConvention"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"),+              Core.projectionFieldName = (Core.Name "nameConvention")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the nameConvention field of hydra.build.format.PackageValidationProfile+packageValidationProfileWithNameConvention :: Typed.TypedTerm Format.PackageValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.PackageValidationProfile+packageValidationProfileWithNameConvention original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "conflictingModuleName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"),+              Core.projectionFieldName = (Core.Name "conflictingModuleName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "duplicateModuleName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"),+              Core.projectionFieldName = (Core.Name "duplicateModuleName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "nameConvention"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.build.format.RepositoryDescriptor+repositoryDescriptor :: Typed.TypedTerm Packaging.Version -> Typed.TypedTerm Packaging.Version -> Typed.TypedTerm (M.Map Format.LanguageName Format.HostOverride) -> Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm [Packaging.PackageName] -> Typed.TypedTerm Format.RepositoryDescriptor+repositoryDescriptor currentVersion hostVersion hostOverrides group author url license packages =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "currentVersion"),+          Core.fieldTerm = (Typed.unTypedTerm currentVersion)},+        Core.Field {+          Core.fieldName = (Core.Name "hostVersion"),+          Core.fieldTerm = (Typed.unTypedTerm hostVersion)},+        Core.Field {+          Core.fieldName = (Core.Name "hostOverrides"),+          Core.fieldTerm = (Typed.unTypedTerm hostOverrides)},+        Core.Field {+          Core.fieldName = (Core.Name "group"),+          Core.fieldTerm = (Typed.unTypedTerm group)},+        Core.Field {+          Core.fieldName = (Core.Name "author"),+          Core.fieldTerm = (Typed.unTypedTerm author)},+        Core.Field {+          Core.fieldName = (Core.Name "url"),+          Core.fieldTerm = (Typed.unTypedTerm url)},+        Core.Field {+          Core.fieldName = (Core.Name "license"),+          Core.fieldTerm = (Typed.unTypedTerm license)},+        Core.Field {+          Core.fieldName = (Core.Name "packages"),+          Core.fieldTerm = (Typed.unTypedTerm packages)}]}))++-- | DSL accessor for the author field of hydra.build.format.RepositoryDescriptor+repositoryDescriptorAuthor :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String+repositoryDescriptorAuthor x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+        Core.projectionFieldName = (Core.Name "author")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the currentVersion field of hydra.build.format.RepositoryDescriptor+repositoryDescriptorCurrentVersion :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm Packaging.Version+repositoryDescriptorCurrentVersion x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+        Core.projectionFieldName = (Core.Name "currentVersion")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the group field of hydra.build.format.RepositoryDescriptor+repositoryDescriptorGroup :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String+repositoryDescriptorGroup x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+        Core.projectionFieldName = (Core.Name "group")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the hostOverrides field of hydra.build.format.RepositoryDescriptor+repositoryDescriptorHostOverrides :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm (M.Map Format.LanguageName Format.HostOverride)+repositoryDescriptorHostOverrides x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+        Core.projectionFieldName = (Core.Name "hostOverrides")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the hostVersion field of hydra.build.format.RepositoryDescriptor+repositoryDescriptorHostVersion :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm Packaging.Version+repositoryDescriptorHostVersion x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+        Core.projectionFieldName = (Core.Name "hostVersion")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the license field of hydra.build.format.RepositoryDescriptor+repositoryDescriptorLicense :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String+repositoryDescriptorLicense x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+        Core.projectionFieldName = (Core.Name "license")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the packages field of hydra.build.format.RepositoryDescriptor+repositoryDescriptorPackages :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm [Packaging.PackageName]+repositoryDescriptorPackages x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+        Core.projectionFieldName = (Core.Name "packages")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.format.RepositoryDescriptor+repositoryDescriptorRepositoryDescriptor :: Typed.TypedName Format.RepositoryDescriptor+repositoryDescriptorRepositoryDescriptor = Typed.TypedName (Core.Name "hydra.build.format.RepositoryDescriptor")++-- | DSL accessor for the url field of hydra.build.format.RepositoryDescriptor+repositoryDescriptorUrl :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String+repositoryDescriptorUrl x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+        Core.projectionFieldName = (Core.Name "url")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the author field of hydra.build.format.RepositoryDescriptor+repositoryDescriptorWithAuthor :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String -> Typed.TypedTerm Format.RepositoryDescriptor+repositoryDescriptorWithAuthor original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "currentVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "currentVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "hostVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "hostVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "hostOverrides"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "hostOverrides")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "group"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "group")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "author"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "url"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "url")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "license"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "license")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "packages"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "packages")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the currentVersion field of hydra.build.format.RepositoryDescriptor+repositoryDescriptorWithCurrentVersion :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm Packaging.Version -> Typed.TypedTerm Format.RepositoryDescriptor+repositoryDescriptorWithCurrentVersion original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "currentVersion"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "hostVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "hostVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "hostOverrides"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "hostOverrides")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "group"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "group")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "author"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "author")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "url"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "url")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "license"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "license")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "packages"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "packages")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the group field of hydra.build.format.RepositoryDescriptor+repositoryDescriptorWithGroup :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String -> Typed.TypedTerm Format.RepositoryDescriptor+repositoryDescriptorWithGroup original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "currentVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "currentVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "hostVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "hostVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "hostOverrides"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "hostOverrides")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "group"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "author"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "author")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "url"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "url")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "license"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "license")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "packages"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "packages")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the hostOverrides field of hydra.build.format.RepositoryDescriptor+repositoryDescriptorWithHostOverrides :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm (M.Map Format.LanguageName Format.HostOverride) -> Typed.TypedTerm Format.RepositoryDescriptor+repositoryDescriptorWithHostOverrides original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "currentVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "currentVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "hostVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "hostVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "hostOverrides"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "group"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "group")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "author"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "author")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "url"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "url")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "license"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "license")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "packages"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "packages")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the hostVersion field of hydra.build.format.RepositoryDescriptor+repositoryDescriptorWithHostVersion :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm Packaging.Version -> Typed.TypedTerm Format.RepositoryDescriptor+repositoryDescriptorWithHostVersion original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "currentVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "currentVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "hostVersion"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "hostOverrides"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "hostOverrides")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "group"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "group")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "author"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "author")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "url"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "url")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "license"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "license")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "packages"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "packages")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the license field of hydra.build.format.RepositoryDescriptor+repositoryDescriptorWithLicense :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String -> Typed.TypedTerm Format.RepositoryDescriptor+repositoryDescriptorWithLicense original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "currentVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "currentVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "hostVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "hostVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "hostOverrides"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "hostOverrides")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "group"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "group")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "author"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "author")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "url"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "url")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "license"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "packages"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "packages")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the packages field of hydra.build.format.RepositoryDescriptor+repositoryDescriptorWithPackages :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm [Packaging.PackageName] -> Typed.TypedTerm Format.RepositoryDescriptor+repositoryDescriptorWithPackages original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "currentVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "currentVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "hostVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "hostVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "hostOverrides"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "hostOverrides")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "group"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "group")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "author"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "author")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "url"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "url")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "license"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "license")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "packages"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL updater for the url field of hydra.build.format.RepositoryDescriptor+repositoryDescriptorWithUrl :: Typed.TypedTerm Format.RepositoryDescriptor -> Typed.TypedTerm String -> Typed.TypedTerm Format.RepositoryDescriptor+repositoryDescriptorWithUrl original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "currentVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "currentVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "hostVersion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "hostVersion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "hostOverrides"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "hostOverrides")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "group"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "group")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "author"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "author")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "url"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "license"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "license")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "packages"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+              Core.projectionFieldName = (Core.Name "packages")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL injection for the error variant of hydra.build.format.Severity+severityError :: Typed.TypedTerm Format.Severity+severityError =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.build.format.Severity"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "error"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL name token for hydra.build.format.Severity+severitySeverity :: Typed.TypedName Format.Severity+severitySeverity = Typed.TypedName (Core.Name "hydra.build.format.Severity")++-- | DSL injection for the warning variant of hydra.build.format.Severity+severityWarning :: Typed.TypedTerm Format.Severity+severityWarning =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.build.format.Severity"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "warning"),+        Core.fieldTerm = Core.TermUnit}}))++-- | DSL constructor for the hydra.build.format.Sha256Hash wrapper+sha256Hash :: Typed.TypedTerm String -> Typed.TypedTerm Format.Sha256Hash+sha256Hash x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.build.format.Sha256Hash"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.format.Sha256Hash+sha256HashSha256Hash :: Typed.TypedName Format.Sha256Hash+sha256HashSha256Hash = Typed.TypedName (Core.Name "hydra.build.format.Sha256Hash")++-- | DSL constructor for hydra.build.format.TermValidationProfile+termValidationProfile :: Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TermValidationProfile+termValidationProfile duplicateBinding emptyTermAnnotation undefinedVariable =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.TermValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "duplicateBinding"),+          Core.fieldTerm = (Typed.unTypedTerm duplicateBinding)},+        Core.Field {+          Core.fieldName = (Core.Name "emptyTermAnnotation"),+          Core.fieldTerm = (Typed.unTypedTerm emptyTermAnnotation)},+        Core.Field {+          Core.fieldName = (Core.Name "undefinedVariable"),+          Core.fieldTerm = (Typed.unTypedTerm undefinedVariable)}]}))++-- | DSL accessor for the duplicateBinding field of hydra.build.format.TermValidationProfile+termValidationProfileDuplicateBinding :: Typed.TypedTerm Format.TermValidationProfile -> Typed.TypedTerm (Maybe Format.Severity)+termValidationProfileDuplicateBinding x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.TermValidationProfile"),+        Core.projectionFieldName = (Core.Name "duplicateBinding")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the emptyTermAnnotation field of hydra.build.format.TermValidationProfile+termValidationProfileEmptyTermAnnotation :: Typed.TypedTerm Format.TermValidationProfile -> Typed.TypedTerm (Maybe Format.Severity)+termValidationProfileEmptyTermAnnotation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.TermValidationProfile"),+        Core.projectionFieldName = (Core.Name "emptyTermAnnotation")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.format.TermValidationProfile+termValidationProfileTermValidationProfile :: Typed.TypedName Format.TermValidationProfile+termValidationProfileTermValidationProfile = Typed.TypedName (Core.Name "hydra.build.format.TermValidationProfile")++-- | DSL accessor for the undefinedVariable field of hydra.build.format.TermValidationProfile+termValidationProfileUndefinedVariable :: Typed.TypedTerm Format.TermValidationProfile -> Typed.TypedTerm (Maybe Format.Severity)+termValidationProfileUndefinedVariable x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.TermValidationProfile"),+        Core.projectionFieldName = (Core.Name "undefinedVariable")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL updater for the duplicateBinding field of hydra.build.format.TermValidationProfile+termValidationProfileWithDuplicateBinding :: Typed.TypedTerm Format.TermValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TermValidationProfile+termValidationProfileWithDuplicateBinding original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.TermValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "duplicateBinding"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "emptyTermAnnotation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.TermValidationProfile"),+              Core.projectionFieldName = (Core.Name "emptyTermAnnotation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "undefinedVariable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.TermValidationProfile"),+              Core.projectionFieldName = (Core.Name "undefinedVariable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the emptyTermAnnotation field of hydra.build.format.TermValidationProfile+termValidationProfileWithEmptyTermAnnotation :: Typed.TypedTerm Format.TermValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TermValidationProfile+termValidationProfileWithEmptyTermAnnotation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.TermValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "duplicateBinding"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.TermValidationProfile"),+              Core.projectionFieldName = (Core.Name "duplicateBinding")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "emptyTermAnnotation"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "undefinedVariable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.TermValidationProfile"),+              Core.projectionFieldName = (Core.Name "undefinedVariable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the undefinedVariable field of hydra.build.format.TermValidationProfile+termValidationProfileWithUndefinedVariable :: Typed.TypedTerm Format.TermValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TermValidationProfile+termValidationProfileWithUndefinedVariable original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.TermValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "duplicateBinding"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.TermValidationProfile"),+              Core.projectionFieldName = (Core.Name "duplicateBinding")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "emptyTermAnnotation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.TermValidationProfile"),+              Core.projectionFieldName = (Core.Name "emptyTermAnnotation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "undefinedVariable"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL constructor for hydra.build.format.TypeValidationProfile+typeValidationProfile :: Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TypeValidationProfile+typeValidationProfile emptyAnnotation duplicateField singleVariantUnion =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "emptyAnnotation"),+          Core.fieldTerm = (Typed.unTypedTerm emptyAnnotation)},+        Core.Field {+          Core.fieldName = (Core.Name "duplicateField"),+          Core.fieldTerm = (Typed.unTypedTerm duplicateField)},+        Core.Field {+          Core.fieldName = (Core.Name "singleVariantUnion"),+          Core.fieldTerm = (Typed.unTypedTerm singleVariantUnion)}]}))++-- | DSL accessor for the duplicateField field of hydra.build.format.TypeValidationProfile+typeValidationProfileDuplicateField :: Typed.TypedTerm Format.TypeValidationProfile -> Typed.TypedTerm (Maybe Format.Severity)+typeValidationProfileDuplicateField x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"),+        Core.projectionFieldName = (Core.Name "duplicateField")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the emptyAnnotation field of hydra.build.format.TypeValidationProfile+typeValidationProfileEmptyAnnotation :: Typed.TypedTerm Format.TypeValidationProfile -> Typed.TypedTerm (Maybe Format.Severity)+typeValidationProfileEmptyAnnotation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"),+        Core.projectionFieldName = (Core.Name "emptyAnnotation")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the singleVariantUnion field of hydra.build.format.TypeValidationProfile+typeValidationProfileSingleVariantUnion :: Typed.TypedTerm Format.TypeValidationProfile -> Typed.TypedTerm (Maybe Format.Severity)+typeValidationProfileSingleVariantUnion x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"),+        Core.projectionFieldName = (Core.Name "singleVariantUnion")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL name token for hydra.build.format.TypeValidationProfile+typeValidationProfileTypeValidationProfile :: Typed.TypedName Format.TypeValidationProfile+typeValidationProfileTypeValidationProfile = Typed.TypedName (Core.Name "hydra.build.format.TypeValidationProfile")++-- | DSL updater for the duplicateField field of hydra.build.format.TypeValidationProfile+typeValidationProfileWithDuplicateField :: Typed.TypedTerm Format.TypeValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TypeValidationProfile+typeValidationProfileWithDuplicateField original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "emptyAnnotation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"),+              Core.projectionFieldName = (Core.Name "emptyAnnotation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "duplicateField"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "singleVariantUnion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"),+              Core.projectionFieldName = (Core.Name "singleVariantUnion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the emptyAnnotation field of hydra.build.format.TypeValidationProfile+typeValidationProfileWithEmptyAnnotation :: Typed.TypedTerm Format.TypeValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TypeValidationProfile+typeValidationProfileWithEmptyAnnotation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "emptyAnnotation"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "duplicateField"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"),+              Core.projectionFieldName = (Core.Name "duplicateField")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "singleVariantUnion"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"),+              Core.projectionFieldName = (Core.Name "singleVariantUnion")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))++-- | DSL updater for the singleVariantUnion field of hydra.build.format.TypeValidationProfile+typeValidationProfileWithSingleVariantUnion :: Typed.TypedTerm Format.TypeValidationProfile -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.TypeValidationProfile+typeValidationProfileWithSingleVariantUnion original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "emptyAnnotation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"),+              Core.projectionFieldName = (Core.Name "emptyAnnotation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "duplicateField"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"),+              Core.projectionFieldName = (Core.Name "duplicateField")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "singleVariantUnion"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))++-- | DSL accessor for the body of hydra.build.format.LanguageName+unLanguageName :: Typed.TypedTerm Format.LanguageName -> Typed.TypedTerm String+unLanguageName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.build.format.LanguageName")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))++-- | DSL accessor for the body of hydra.build.format.Sha256Hash+unSha256Hash :: Typed.TypedTerm Format.Sha256Hash -> Typed.TypedTerm String+unSha256Hash x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.build.format.Sha256Hash")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))

@@ -0,0 +1,412 @@+-- Note: this is an automatically generated file. Do not edit.++-- | Term encoders for hydra.build.format++module Hydra.Encode.Build.Format where++import qualified Hydra.Build.Format as Format+import qualified Hydra.Core as Core+import qualified Hydra.Encode.Packaging as Packaging+import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists+import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps+import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci++-- | Encoder for hydra.build.format.DefinitionNameConventionProfile+definitionNameConventionProfile :: Format.DefinitionNameConventionProfile -> Core.Term+definitionNameConventionProfile x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionNameConventionProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "severity"),+          Core.fieldTerm = (severity (Format.definitionNameConventionProfileSeverity x))},+        Core.Field {+          Core.fieldName = (Core.Name "allowUnderscores"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralBoolean x2)) (Format.definitionNameConventionProfileAllowUnderscores x))}]})++-- | Encoder for hydra.build.format.DefinitionValidationProfile+definitionValidationProfile :: Format.DefinitionValidationProfile -> Core.Term+definitionValidationProfile x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "hasDescription"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map documentationProfile opt)) (Format.definitionValidationProfileHasDescription x))},+        Core.Field {+          Core.fieldName = (Core.Name "ordering"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.definitionValidationProfileOrdering x))},+        Core.Field {+          Core.fieldName = (Core.Name "nameConvention"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map definitionNameConventionProfile opt)) (Format.definitionValidationProfileNameConvention x))},+        Core.Field {+          Core.fieldName = (Core.Name "notInModuleName"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.definitionValidationProfileNotInModuleName x))},+        Core.Field {+          Core.fieldName = (Core.Name "duplicateName"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.definitionValidationProfileDuplicateName x))}]})++-- | Encoder for hydra.build.format.DigestEntry+digestEntry :: Format.DigestEntry -> Core.Term+digestEntry x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.DigestEntry"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "kind"),+          Core.fieldTerm = (digestKind (Format.digestEntryKind x))},+        Core.Field {+          Core.fieldName = (Core.Name "hash"),+          Core.fieldTerm = (sha256Hash (Format.digestEntryHash x))}]})++-- | Encoder for hydra.build.format.DigestKind+digestKind :: Format.DigestKind -> Core.Term+digestKind x =+    case x of+      Format.DigestKindDslSource -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.build.format.DigestKind"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "dslSource"),+          Core.fieldTerm = Core.TermUnit}})+      Format.DigestKindJsonFile -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.build.format.DigestKind"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "jsonFile"),+          Core.fieldTerm = Core.TermUnit}})+      Format.DigestKindTargetFile -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.build.format.DigestKind"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "targetFile"),+          Core.fieldTerm = Core.TermUnit}})+      Format.DigestKindRuntimeFile -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.build.format.DigestKind"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "runtimeFile"),+          Core.fieldTerm = Core.TermUnit}})+      Format.DigestKindOther -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.build.format.DigestKind"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "other"),+          Core.fieldTerm = Core.TermUnit}})++-- | Encoder for hydra.build.format.DocumentationProfile+documentationProfile :: Format.DocumentationProfile -> Core.Term+documentationProfile x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.DocumentationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "severity"),+          Core.fieldTerm = (severity (Format.documentationProfileSeverity x))},+        Core.Field {+          Core.fieldName = (Core.Name "exemptDeprecated"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralBoolean x2)) (Format.documentationProfileExemptDeprecated x))}]})++-- | Encoder for hydra.build.format.Generation+generation :: Format.Generation -> Core.Term+generation x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.Generation"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "generatorId"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.generationGeneratorId x))},+        Core.Field {+          Core.fieldName = (Core.Name "mode"),+          Core.fieldTerm = (generationMode (Format.generationMode x))},+        Core.Field {+          Core.fieldName = (Core.Name "host"),+          Core.fieldTerm = (languageName (Format.generationHost x))},+        Core.Field {+          Core.fieldName = (Core.Name "hydraVersion"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map Packaging.version opt)) (Format.generationHydraVersion x))},+        Core.Field {+          Core.fieldName = (Core.Name "revision"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map (\x2 -> Core.TermLiteral (Core.LiteralString x2)) opt)) (Format.generationRevision x))},+        Core.Field {+          Core.fieldName = (Core.Name "timestamp"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map (\x2 -> Core.TermLiteral (Core.LiteralString x2)) opt)) (Format.generationTimestamp x))}]})++-- | Encoder for hydra.build.format.GenerationMode+generationMode :: Format.GenerationMode -> Core.Term+generationMode x =+    case x of+      Format.GenerationModePublished -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.build.format.GenerationMode"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "published"),+          Core.fieldTerm = Core.TermUnit}})+      Format.GenerationModeShim -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.build.format.GenerationMode"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "shim"),+          Core.fieldTerm = Core.TermUnit}})++-- | Encoder for hydra.build.format.HostOverride+hostOverride :: Format.HostOverride -> Core.Term+hostOverride x =+    case x of+      Format.HostOverrideLocal -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.build.format.HostOverride"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "local"),+          Core.fieldTerm = Core.TermUnit}})+      Format.HostOverrideVersion v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.build.format.HostOverride"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "version"),+          Core.fieldTerm = (Packaging.version v0)}})++-- | Encoder for hydra.build.format.InputDigest+inputDigest :: Format.InputDigest -> Core.Term+inputDigest x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.InputDigest"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "digestFormatVersion"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Format.inputDigestDigestFormatVersion x))},+        Core.Field {+          Core.fieldName = (Core.Name "moduleFormatVersion"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Format.inputDigestModuleFormatVersion x))},+        Core.Field {+          Core.fieldName = (Core.Name "selfHash"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map sha256Hash opt)) (Format.inputDigestSelfHash x))},+        Core.Field {+          Core.fieldName = (Core.Name "dependencyHashes"),+          Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap Packaging.packageName sha256Hash m)) (Format.inputDigestDependencyHashes x))},+        Core.Field {+          Core.fieldName = (Core.Name "moduleHashes"),+          Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap Packaging.moduleName sha256Hash m)) (Format.inputDigestModuleHashes x))}]})++-- | Encoder for hydra.build.format.LanguageName+languageName :: Format.LanguageName -> Core.Term+languageName x =+    Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.build.format.LanguageName"),+      Core.wrappedTermBody = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.unLanguageName x))})++-- | Encoder for hydra.build.format.ModuleValidationProfile+moduleValidationProfile :: Format.ModuleValidationProfile -> Core.Term+moduleValidationProfile x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "definitions"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map definitionValidationProfile opt)) (Format.moduleValidationProfileDefinitions x))},+        Core.Field {+          Core.fieldName = (Core.Name "nameConvention"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.moduleValidationProfileNameConvention x))},+        Core.Field {+          Core.fieldName = (Core.Name "conflictingVariantName"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.moduleValidationProfileConflictingVariantName x))}]})++-- | Encoder for hydra.build.format.OutputDigest+outputDigest :: Format.OutputDigest -> Core.Term+outputDigest x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.OutputDigest"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "digestFormatVersion"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Format.outputDigestDigestFormatVersion x))},+        Core.Field {+          Core.fieldName = (Core.Name "moduleFormatVersion"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Format.outputDigestModuleFormatVersion x))},+        Core.Field {+          Core.fieldName = (Core.Name "generator"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.outputDigestGenerator x))},+        Core.Field {+          Core.fieldName = (Core.Name "generation"),+          Core.fieldTerm = (generation (Format.outputDigestGeneration x))},+        Core.Field {+          Core.fieldName = (Core.Name "selfHash"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map sha256Hash opt)) (Format.outputDigestSelfHash x))},+        Core.Field {+          Core.fieldName = (Core.Name "dependencyHashes"),+          Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap Packaging.packageName sha256Hash m)) (Format.outputDigestDependencyHashes x))},+        Core.Field {+          Core.fieldName = (Core.Name "inputs"),+          Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap (\x2 -> Core.TermLiteral (Core.LiteralString x2)) digestEntry m)) (Format.outputDigestInputs x))},+        Core.Field {+          Core.fieldName = (Core.Name "outputs"),+          Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap (\x2 -> Core.TermLiteral (Core.LiteralString x2)) digestEntry m)) (Format.outputDigestOutputs x))}]})++-- | Encoder for hydra.build.format.PackageDescriptor+packageDescriptor :: Format.PackageDescriptor -> Core.Term+packageDescriptor x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "packageFormatVersion"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Format.packageDescriptorPackageFormatVersion x))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Packaging.packageName (Format.packageDescriptorName x))},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.packageDescriptorDescription x))},+        Core.Field {+          Core.fieldName = (Core.Name "sourceLanguage"),+          Core.fieldTerm = (languageName (Format.packageDescriptorSourceLanguage x))},+        Core.Field {+          Core.fieldName = (Core.Name "targetLanguages"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map (\xs -> Core.TermList (Lists.map languageName xs)) opt)) (Format.packageDescriptorTargetLanguages x))},+        Core.Field {+          Core.fieldName = (Core.Name "dependencies"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map Packaging.packageName xs)) (Format.packageDescriptorDependencies x))},+        Core.Field {+          Core.fieldName = (Core.Name "validation"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map packageValidationConfiguration opt)) (Format.packageDescriptorValidation x))}]})++-- | Encoder for hydra.build.format.PackageManifest+packageManifest :: Format.PackageManifest -> Core.Term+packageManifest x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.PackageManifest"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "manifestFormatVersion"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Format.packageManifestManifestFormatVersion x))},+        Core.Field {+          Core.fieldName = (Core.Name "moduleFormatVersion"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Format.packageManifestModuleFormatVersion x))},+        Core.Field {+          Core.fieldName = (Core.Name "package"),+          Core.fieldTerm = (Packaging.packageName (Format.packageManifestPackage x))},+        Core.Field {+          Core.fieldName = (Core.Name "mainModules"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map Packaging.moduleName xs)) (Format.packageManifestMainModules x))},+        Core.Field {+          Core.fieldName = (Core.Name "testModules"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map Packaging.moduleName xs)) (Format.packageManifestTestModules x))},+        Core.Field {+          Core.fieldName = (Core.Name "mainDslModules"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map Packaging.moduleName xs)) (Format.packageManifestMainDslModules x))},+        Core.Field {+          Core.fieldName = (Core.Name "mainEncodingModules"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map Packaging.moduleName xs)) (Format.packageManifestMainEncodingModules x))}]})++-- | Encoder for hydra.build.format.PackageValidationConfiguration+packageValidationConfiguration :: Format.PackageValidationConfiguration -> Core.Term+packageValidationConfiguration x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "package"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map packageValidationProfile opt)) (Format.packageValidationConfigurationPackage x))},+        Core.Field {+          Core.fieldName = (Core.Name "module"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map moduleValidationProfile opt)) (Format.packageValidationConfigurationModule x))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map typeValidationProfile opt)) (Format.packageValidationConfigurationType x))},+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map termValidationProfile opt)) (Format.packageValidationConfigurationTerm x))}]})++-- | Encoder for hydra.build.format.PackageValidationProfile+packageValidationProfile :: Format.PackageValidationProfile -> Core.Term+packageValidationProfile x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "conflictingModuleName"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.packageValidationProfileConflictingModuleName x))},+        Core.Field {+          Core.fieldName = (Core.Name "duplicateModuleName"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.packageValidationProfileDuplicateModuleName x))},+        Core.Field {+          Core.fieldName = (Core.Name "nameConvention"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.packageValidationProfileNameConvention x))}]})++-- | Encoder for hydra.build.format.RepositoryDescriptor+repositoryDescriptor :: Format.RepositoryDescriptor -> Core.Term+repositoryDescriptor x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "currentVersion"),+          Core.fieldTerm = (Packaging.version (Format.repositoryDescriptorCurrentVersion x))},+        Core.Field {+          Core.fieldName = (Core.Name "hostVersion"),+          Core.fieldTerm = (Packaging.version (Format.repositoryDescriptorHostVersion x))},+        Core.Field {+          Core.fieldName = (Core.Name "hostOverrides"),+          Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap languageName hostOverride m)) (Format.repositoryDescriptorHostOverrides x))},+        Core.Field {+          Core.fieldName = (Core.Name "group"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.repositoryDescriptorGroup x))},+        Core.Field {+          Core.fieldName = (Core.Name "author"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.repositoryDescriptorAuthor x))},+        Core.Field {+          Core.fieldName = (Core.Name "url"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.repositoryDescriptorUrl x))},+        Core.Field {+          Core.fieldName = (Core.Name "license"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.repositoryDescriptorLicense x))},+        Core.Field {+          Core.fieldName = (Core.Name "packages"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map Packaging.packageName xs)) (Format.repositoryDescriptorPackages x))}]})++-- | Encoder for hydra.build.format.Severity+severity :: Format.Severity -> Core.Term+severity x =+    case x of+      Format.SeverityError -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.build.format.Severity"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "error"),+          Core.fieldTerm = Core.TermUnit}})+      Format.SeverityWarning -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.build.format.Severity"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "warning"),+          Core.fieldTerm = Core.TermUnit}})++-- | Encoder for hydra.build.format.Sha256Hash+sha256Hash :: Format.Sha256Hash -> Core.Term+sha256Hash x =+    Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.build.format.Sha256Hash"),+      Core.wrappedTermBody = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.unSha256Hash x))})++-- | Encoder for hydra.build.format.TermValidationProfile+termValidationProfile :: Format.TermValidationProfile -> Core.Term+termValidationProfile x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.TermValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "duplicateBinding"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.termValidationProfileDuplicateBinding x))},+        Core.Field {+          Core.fieldName = (Core.Name "emptyTermAnnotation"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.termValidationProfileEmptyTermAnnotation x))},+        Core.Field {+          Core.fieldName = (Core.Name "undefinedVariable"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.termValidationProfileUndefinedVariable x))}]})++-- | Encoder for hydra.build.format.TypeValidationProfile+typeValidationProfile :: Format.TypeValidationProfile -> Core.Term+typeValidationProfile x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "emptyAnnotation"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.typeValidationProfileEmptyAnnotation x))},+        Core.Field {+          Core.fieldName = (Core.Name "duplicateField"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.typeValidationProfileDuplicateField x))},+        Core.Field {+          Core.fieldName = (Core.Name "singleVariantUnion"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.typeValidationProfileSingleVariantUnion x))}]})