hydra-python-0.18.0: src/main/haskell/Hydra/Python/Dsl/Environment.hs

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

-- | DSL functions for hydra.python.environment

module Hydra.Python.Dsl.Environment where

import qualified Hydra.Core.Graph as Graph
import qualified Hydra.Core.Model as Model
import qualified Hydra.Core.Packaging as Packaging
import qualified Hydra.Core.Typed as Typed
import qualified Hydra.Core.Typing as Typing
import qualified Hydra.Core.Util as Util
import qualified Hydra.Python.Dsl.Syntax as DslSyntax
import qualified Hydra.Python.Environment as Environment
import qualified Hydra.Python.Syntax as Syntax
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
import qualified Data.Scientific as Sci
import Data.Void
import qualified Data.Map as M
import qualified Data.Set as S

-- | DSL constructor for hydra.python.environment.PyGraph
pyGraph :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Environment.PyGraph
pyGraph graph metadata =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PyGraph"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "graph"),
          Model.fieldTerm = (Typed.unTypedTerm graph)},
        Model.Field {
          Model.fieldName = (Model.Name "metadata"),
          Model.fieldTerm = (Typed.unTypedTerm metadata)}]}))

-- | DSL accessor for the graph field of hydra.python.environment.PyGraph
pyGraphGraph :: Typed.TypedTerm Environment.PyGraph -> Typed.TypedTerm Graph.Graph
pyGraphGraph x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PyGraph"),
        Model.projectionFieldName = (Model.Name "graph")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the metadata field of hydra.python.environment.PyGraph
pyGraphMetadata :: Typed.TypedTerm Environment.PyGraph -> Typed.TypedTerm Environment.PythonModuleMetadata
pyGraphMetadata x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PyGraph"),
        Model.projectionFieldName = (Model.Name "metadata")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.python.environment.PyGraph
pyGraphPyGraph :: Typed.TypedName Environment.PyGraph
pyGraphPyGraph = Typed.TypedName (Model.Name "hydra.python.environment.PyGraph")

-- | DSL updater for the graph field of hydra.python.environment.PyGraph
pyGraphWithGraph :: Typed.TypedTerm Environment.PyGraph -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Environment.PyGraph
pyGraphWithGraph original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PyGraph"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "graph"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "metadata"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PyGraph"),
              Model.projectionFieldName = (Model.Name "metadata")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the metadata field of hydra.python.environment.PyGraph
pyGraphWithMetadata :: Typed.TypedTerm Environment.PyGraph -> Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Environment.PyGraph
pyGraphWithMetadata original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PyGraph"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "graph"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PyGraph"),
              Model.projectionFieldName = (Model.Name "graph")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "metadata"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.python.environment.PythonEnvironment
pythonEnvironment :: Typed.TypedTerm (Util.ModuleNames Syntax.DottedName) -> Typed.TypedTerm ([Model.Name], (M.Map Model.Name Syntax.Name)) -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm (S.Set Model.Name) -> Typed.TypedTerm Environment.PythonVersion -> Typed.TypedTerm Bool -> Typed.TypedTerm (S.Set Model.Name) -> Typed.TypedTerm (S.Set String) -> Typed.TypedTerm Environment.PythonEnvironment
pythonEnvironment namespaces boundTypeVariables graph nullaryBindings version skipCasts inlineVariables overlaySubs =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Typed.unTypedTerm namespaces)},
        Model.Field {
          Model.fieldName = (Model.Name "boundTypeVariables"),
          Model.fieldTerm = (Typed.unTypedTerm boundTypeVariables)},
        Model.Field {
          Model.fieldName = (Model.Name "graph"),
          Model.fieldTerm = (Typed.unTypedTerm graph)},
        Model.Field {
          Model.fieldName = (Model.Name "nullaryBindings"),
          Model.fieldTerm = (Typed.unTypedTerm nullaryBindings)},
        Model.Field {
          Model.fieldName = (Model.Name "version"),
          Model.fieldTerm = (Typed.unTypedTerm version)},
        Model.Field {
          Model.fieldName = (Model.Name "skipCasts"),
          Model.fieldTerm = (Typed.unTypedTerm skipCasts)},
        Model.Field {
          Model.fieldName = (Model.Name "inlineVariables"),
          Model.fieldTerm = (Typed.unTypedTerm inlineVariables)},
        Model.Field {
          Model.fieldName = (Model.Name "overlaySubs"),
          Model.fieldTerm = (Typed.unTypedTerm overlaySubs)}]}))

-- | DSL accessor for the boundTypeVariables field of hydra.python.environment.PythonEnvironment
pythonEnvironmentBoundTypeVariables :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm ([Model.Name], (M.Map Model.Name Syntax.Name))
pythonEnvironmentBoundTypeVariables x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
        Model.projectionFieldName = (Model.Name "boundTypeVariables")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the graph field of hydra.python.environment.PythonEnvironment
pythonEnvironmentGraph :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm Graph.Graph
pythonEnvironmentGraph x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
        Model.projectionFieldName = (Model.Name "graph")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the inlineVariables field of hydra.python.environment.PythonEnvironment
pythonEnvironmentInlineVariables :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm (S.Set Model.Name)
pythonEnvironmentInlineVariables x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
        Model.projectionFieldName = (Model.Name "inlineVariables")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the namespaces field of hydra.python.environment.PythonEnvironment
pythonEnvironmentNamespaces :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm (Util.ModuleNames Syntax.DottedName)
pythonEnvironmentNamespaces x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
        Model.projectionFieldName = (Model.Name "namespaces")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the nullaryBindings field of hydra.python.environment.PythonEnvironment
pythonEnvironmentNullaryBindings :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm (S.Set Model.Name)
pythonEnvironmentNullaryBindings x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
        Model.projectionFieldName = (Model.Name "nullaryBindings")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the overlaySubs field of hydra.python.environment.PythonEnvironment
pythonEnvironmentOverlaySubs :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm (S.Set String)
pythonEnvironmentOverlaySubs x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
        Model.projectionFieldName = (Model.Name "overlaySubs")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.python.environment.PythonEnvironment
pythonEnvironmentPythonEnvironment :: Typed.TypedName Environment.PythonEnvironment
pythonEnvironmentPythonEnvironment = Typed.TypedName (Model.Name "hydra.python.environment.PythonEnvironment")

-- | DSL accessor for the skipCasts field of hydra.python.environment.PythonEnvironment
pythonEnvironmentSkipCasts :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm Bool
pythonEnvironmentSkipCasts x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
        Model.projectionFieldName = (Model.Name "skipCasts")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the version field of hydra.python.environment.PythonEnvironment
pythonEnvironmentVersion :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm Environment.PythonVersion
pythonEnvironmentVersion x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
        Model.projectionFieldName = (Model.Name "version")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the boundTypeVariables field of hydra.python.environment.PythonEnvironment
pythonEnvironmentWithBoundTypeVariables :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm ([Model.Name], (M.Map Model.Name Syntax.Name)) -> Typed.TypedTerm Environment.PythonEnvironment
pythonEnvironmentWithBoundTypeVariables original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "namespaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "boundTypeVariables"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "graph"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "graph")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "nullaryBindings"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "nullaryBindings")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "version"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "version")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "skipCasts"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "skipCasts")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "inlineVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "inlineVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "overlaySubs"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "overlaySubs")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the graph field of hydra.python.environment.PythonEnvironment
pythonEnvironmentWithGraph :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Environment.PythonEnvironment
pythonEnvironmentWithGraph original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "namespaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "boundTypeVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "boundTypeVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "graph"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "nullaryBindings"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "nullaryBindings")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "version"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "version")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "skipCasts"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "skipCasts")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "inlineVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "inlineVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "overlaySubs"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "overlaySubs")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the inlineVariables field of hydra.python.environment.PythonEnvironment
pythonEnvironmentWithInlineVariables :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm (S.Set Model.Name) -> Typed.TypedTerm Environment.PythonEnvironment
pythonEnvironmentWithInlineVariables original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "namespaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "boundTypeVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "boundTypeVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "graph"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "graph")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "nullaryBindings"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "nullaryBindings")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "version"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "version")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "skipCasts"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "skipCasts")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "inlineVariables"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "overlaySubs"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "overlaySubs")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the namespaces field of hydra.python.environment.PythonEnvironment
pythonEnvironmentWithNamespaces :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm (Util.ModuleNames Syntax.DottedName) -> Typed.TypedTerm Environment.PythonEnvironment
pythonEnvironmentWithNamespaces original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "boundTypeVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "boundTypeVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "graph"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "graph")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "nullaryBindings"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "nullaryBindings")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "version"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "version")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "skipCasts"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "skipCasts")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "inlineVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "inlineVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "overlaySubs"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "overlaySubs")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the nullaryBindings field of hydra.python.environment.PythonEnvironment
pythonEnvironmentWithNullaryBindings :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm (S.Set Model.Name) -> Typed.TypedTerm Environment.PythonEnvironment
pythonEnvironmentWithNullaryBindings original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "namespaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "boundTypeVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "boundTypeVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "graph"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "graph")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "nullaryBindings"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "version"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "version")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "skipCasts"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "skipCasts")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "inlineVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "inlineVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "overlaySubs"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "overlaySubs")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the overlaySubs field of hydra.python.environment.PythonEnvironment
pythonEnvironmentWithOverlaySubs :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm (S.Set String) -> Typed.TypedTerm Environment.PythonEnvironment
pythonEnvironmentWithOverlaySubs original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "namespaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "boundTypeVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "boundTypeVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "graph"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "graph")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "nullaryBindings"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "nullaryBindings")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "version"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "version")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "skipCasts"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "skipCasts")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "inlineVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "inlineVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "overlaySubs"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the skipCasts field of hydra.python.environment.PythonEnvironment
pythonEnvironmentWithSkipCasts :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonEnvironment
pythonEnvironmentWithSkipCasts original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "namespaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "boundTypeVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "boundTypeVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "graph"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "graph")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "nullaryBindings"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "nullaryBindings")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "version"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "version")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "skipCasts"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "inlineVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "inlineVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "overlaySubs"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "overlaySubs")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the version field of hydra.python.environment.PythonEnvironment
pythonEnvironmentWithVersion :: Typed.TypedTerm Environment.PythonEnvironment -> Typed.TypedTerm Environment.PythonVersion -> Typed.TypedTerm Environment.PythonEnvironment
pythonEnvironmentWithVersion original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "namespaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "boundTypeVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "boundTypeVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "graph"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "graph")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "nullaryBindings"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "nullaryBindings")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "version"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "skipCasts"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "skipCasts")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "inlineVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "inlineVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "overlaySubs"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonEnvironment"),
              Model.projectionFieldName = (Model.Name "overlaySubs")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.python.environment.PythonModuleMetadata
pythonModuleMetadata :: Typed.TypedTerm (Util.ModuleNames Syntax.DottedName) -> Typed.TypedTerm (S.Set Model.Name) -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata
pythonModuleMetadata namespaces typeVariables usesAnnotated usesCallable usesCast usesLruCache usesTypeAlias usesDataclass usesDecimal usesEither usesEnum usesFrozenDict usesFrozenList usesFrozenSet usesGeneric usesJust usesLeft usesMaybe usesName usesNode usesNothing usesRight usesTypeVar =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Typed.unTypedTerm namespaces)},
        Model.Field {
          Model.fieldName = (Model.Name "typeVariables"),
          Model.fieldTerm = (Typed.unTypedTerm typeVariables)},
        Model.Field {
          Model.fieldName = (Model.Name "usesAnnotated"),
          Model.fieldTerm = (Typed.unTypedTerm usesAnnotated)},
        Model.Field {
          Model.fieldName = (Model.Name "usesCallable"),
          Model.fieldTerm = (Typed.unTypedTerm usesCallable)},
        Model.Field {
          Model.fieldName = (Model.Name "usesCast"),
          Model.fieldTerm = (Typed.unTypedTerm usesCast)},
        Model.Field {
          Model.fieldName = (Model.Name "usesLruCache"),
          Model.fieldTerm = (Typed.unTypedTerm usesLruCache)},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeAlias"),
          Model.fieldTerm = (Typed.unTypedTerm usesTypeAlias)},
        Model.Field {
          Model.fieldName = (Model.Name "usesDataclass"),
          Model.fieldTerm = (Typed.unTypedTerm usesDataclass)},
        Model.Field {
          Model.fieldName = (Model.Name "usesDecimal"),
          Model.fieldTerm = (Typed.unTypedTerm usesDecimal)},
        Model.Field {
          Model.fieldName = (Model.Name "usesEither"),
          Model.fieldTerm = (Typed.unTypedTerm usesEither)},
        Model.Field {
          Model.fieldName = (Model.Name "usesEnum"),
          Model.fieldTerm = (Typed.unTypedTerm usesEnum)},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenDict"),
          Model.fieldTerm = (Typed.unTypedTerm usesFrozenDict)},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenList"),
          Model.fieldTerm = (Typed.unTypedTerm usesFrozenList)},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenSet"),
          Model.fieldTerm = (Typed.unTypedTerm usesFrozenSet)},
        Model.Field {
          Model.fieldName = (Model.Name "usesGeneric"),
          Model.fieldTerm = (Typed.unTypedTerm usesGeneric)},
        Model.Field {
          Model.fieldName = (Model.Name "usesJust"),
          Model.fieldTerm = (Typed.unTypedTerm usesJust)},
        Model.Field {
          Model.fieldName = (Model.Name "usesLeft"),
          Model.fieldTerm = (Typed.unTypedTerm usesLeft)},
        Model.Field {
          Model.fieldName = (Model.Name "usesMaybe"),
          Model.fieldTerm = (Typed.unTypedTerm usesMaybe)},
        Model.Field {
          Model.fieldName = (Model.Name "usesName"),
          Model.fieldTerm = (Typed.unTypedTerm usesName)},
        Model.Field {
          Model.fieldName = (Model.Name "usesNode"),
          Model.fieldTerm = (Typed.unTypedTerm usesNode)},
        Model.Field {
          Model.fieldName = (Model.Name "usesNothing"),
          Model.fieldTerm = (Typed.unTypedTerm usesNothing)},
        Model.Field {
          Model.fieldName = (Model.Name "usesRight"),
          Model.fieldTerm = (Typed.unTypedTerm usesRight)},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeVar"),
          Model.fieldTerm = (Typed.unTypedTerm usesTypeVar)}]}))

-- | DSL accessor for the namespaces field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataNamespaces :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm (Util.ModuleNames Syntax.DottedName)
pythonModuleMetadataNamespaces x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
        Model.projectionFieldName = (Model.Name "namespaces")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataPythonModuleMetadata :: Typed.TypedName Environment.PythonModuleMetadata
pythonModuleMetadataPythonModuleMetadata = Typed.TypedName (Model.Name "hydra.python.environment.PythonModuleMetadata")

-- | DSL accessor for the typeVariables field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataTypeVariables :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm (S.Set Model.Name)
pythonModuleMetadataTypeVariables x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
        Model.projectionFieldName = (Model.Name "typeVariables")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the usesAnnotated field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataUsesAnnotated :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool
pythonModuleMetadataUsesAnnotated x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
        Model.projectionFieldName = (Model.Name "usesAnnotated")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the usesCallable field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataUsesCallable :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool
pythonModuleMetadataUsesCallable x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
        Model.projectionFieldName = (Model.Name "usesCallable")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the usesCast field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataUsesCast :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool
pythonModuleMetadataUsesCast x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
        Model.projectionFieldName = (Model.Name "usesCast")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the usesDataclass field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataUsesDataclass :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool
pythonModuleMetadataUsesDataclass x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
        Model.projectionFieldName = (Model.Name "usesDataclass")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the usesDecimal field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataUsesDecimal :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool
pythonModuleMetadataUsesDecimal x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
        Model.projectionFieldName = (Model.Name "usesDecimal")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the usesEither field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataUsesEither :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool
pythonModuleMetadataUsesEither x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
        Model.projectionFieldName = (Model.Name "usesEither")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the usesEnum field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataUsesEnum :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool
pythonModuleMetadataUsesEnum x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
        Model.projectionFieldName = (Model.Name "usesEnum")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the usesFrozenDict field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataUsesFrozenDict :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool
pythonModuleMetadataUsesFrozenDict x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
        Model.projectionFieldName = (Model.Name "usesFrozenDict")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the usesFrozenList field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataUsesFrozenList :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool
pythonModuleMetadataUsesFrozenList x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
        Model.projectionFieldName = (Model.Name "usesFrozenList")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the usesFrozenSet field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataUsesFrozenSet :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool
pythonModuleMetadataUsesFrozenSet x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
        Model.projectionFieldName = (Model.Name "usesFrozenSet")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the usesGeneric field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataUsesGeneric :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool
pythonModuleMetadataUsesGeneric x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
        Model.projectionFieldName = (Model.Name "usesGeneric")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the usesJust field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataUsesJust :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool
pythonModuleMetadataUsesJust x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
        Model.projectionFieldName = (Model.Name "usesJust")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the usesLeft field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataUsesLeft :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool
pythonModuleMetadataUsesLeft x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
        Model.projectionFieldName = (Model.Name "usesLeft")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the usesLruCache field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataUsesLruCache :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool
pythonModuleMetadataUsesLruCache x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
        Model.projectionFieldName = (Model.Name "usesLruCache")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the usesMaybe field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataUsesMaybe :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool
pythonModuleMetadataUsesMaybe x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
        Model.projectionFieldName = (Model.Name "usesMaybe")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the usesName field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataUsesName :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool
pythonModuleMetadataUsesName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
        Model.projectionFieldName = (Model.Name "usesName")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the usesNode field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataUsesNode :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool
pythonModuleMetadataUsesNode x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
        Model.projectionFieldName = (Model.Name "usesNode")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the usesNothing field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataUsesNothing :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool
pythonModuleMetadataUsesNothing x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
        Model.projectionFieldName = (Model.Name "usesNothing")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the usesRight field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataUsesRight :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool
pythonModuleMetadataUsesRight x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
        Model.projectionFieldName = (Model.Name "usesRight")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the usesTypeAlias field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataUsesTypeAlias :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool
pythonModuleMetadataUsesTypeAlias x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
        Model.projectionFieldName = (Model.Name "usesTypeAlias")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the usesTypeVar field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataUsesTypeVar :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool
pythonModuleMetadataUsesTypeVar x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
        Model.projectionFieldName = (Model.Name "usesTypeVar")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the namespaces field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataWithNamespaces :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm (Util.ModuleNames Syntax.DottedName) -> Typed.TypedTerm Environment.PythonModuleMetadata
pythonModuleMetadataWithNamespaces original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "typeVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "typeVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesAnnotated"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesAnnotated")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCallable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCallable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCast"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCast")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLruCache"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLruCache")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeAlias"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeAlias")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDataclass"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDataclass")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDecimal"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDecimal")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEither"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEither")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEnum"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEnum")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenDict"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenDict")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenList"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenList")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenSet"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenSet")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesGeneric"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesGeneric")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesJust"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesJust")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLeft"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLeft")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesMaybe"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesMaybe")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNode"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNode")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNothing"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNothing")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesRight"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesRight")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeVar"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeVar")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the typeVariables field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataWithTypeVariables :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm (S.Set Model.Name) -> Typed.TypedTerm Environment.PythonModuleMetadata
pythonModuleMetadataWithTypeVariables original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "namespaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeVariables"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "usesAnnotated"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesAnnotated")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCallable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCallable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCast"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCast")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLruCache"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLruCache")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeAlias"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeAlias")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDataclass"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDataclass")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDecimal"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDecimal")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEither"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEither")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEnum"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEnum")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenDict"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenDict")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenList"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenList")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenSet"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenSet")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesGeneric"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesGeneric")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesJust"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesJust")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLeft"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLeft")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesMaybe"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesMaybe")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNode"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNode")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNothing"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNothing")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesRight"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesRight")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeVar"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeVar")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the usesAnnotated field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataWithUsesAnnotated :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata
pythonModuleMetadataWithUsesAnnotated original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "namespaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "typeVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesAnnotated"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "usesCallable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCallable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCast"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCast")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLruCache"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLruCache")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeAlias"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeAlias")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDataclass"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDataclass")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDecimal"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDecimal")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEither"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEither")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEnum"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEnum")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenDict"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenDict")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenList"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenList")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenSet"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenSet")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesGeneric"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesGeneric")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesJust"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesJust")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLeft"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLeft")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesMaybe"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesMaybe")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNode"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNode")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNothing"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNothing")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesRight"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesRight")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeVar"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeVar")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the usesCallable field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataWithUsesCallable :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata
pythonModuleMetadataWithUsesCallable original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "namespaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "typeVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesAnnotated"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesAnnotated")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCallable"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "usesCast"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCast")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLruCache"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLruCache")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeAlias"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeAlias")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDataclass"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDataclass")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDecimal"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDecimal")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEither"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEither")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEnum"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEnum")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenDict"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenDict")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenList"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenList")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenSet"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenSet")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesGeneric"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesGeneric")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesJust"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesJust")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLeft"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLeft")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesMaybe"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesMaybe")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNode"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNode")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNothing"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNothing")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesRight"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesRight")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeVar"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeVar")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the usesCast field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataWithUsesCast :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata
pythonModuleMetadataWithUsesCast original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "namespaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "typeVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesAnnotated"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesAnnotated")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCallable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCallable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCast"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "usesLruCache"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLruCache")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeAlias"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeAlias")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDataclass"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDataclass")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDecimal"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDecimal")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEither"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEither")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEnum"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEnum")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenDict"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenDict")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenList"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenList")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenSet"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenSet")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesGeneric"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesGeneric")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesJust"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesJust")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLeft"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLeft")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesMaybe"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesMaybe")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNode"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNode")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNothing"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNothing")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesRight"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesRight")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeVar"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeVar")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the usesDataclass field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataWithUsesDataclass :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata
pythonModuleMetadataWithUsesDataclass original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "namespaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "typeVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesAnnotated"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesAnnotated")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCallable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCallable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCast"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCast")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLruCache"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLruCache")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeAlias"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeAlias")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDataclass"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "usesDecimal"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDecimal")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEither"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEither")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEnum"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEnum")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenDict"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenDict")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenList"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenList")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenSet"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenSet")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesGeneric"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesGeneric")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesJust"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesJust")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLeft"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLeft")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesMaybe"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesMaybe")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNode"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNode")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNothing"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNothing")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesRight"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesRight")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeVar"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeVar")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the usesDecimal field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataWithUsesDecimal :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata
pythonModuleMetadataWithUsesDecimal original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "namespaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "typeVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesAnnotated"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesAnnotated")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCallable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCallable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCast"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCast")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLruCache"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLruCache")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeAlias"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeAlias")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDataclass"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDataclass")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDecimal"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "usesEither"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEither")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEnum"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEnum")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenDict"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenDict")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenList"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenList")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenSet"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenSet")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesGeneric"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesGeneric")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesJust"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesJust")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLeft"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLeft")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesMaybe"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesMaybe")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNode"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNode")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNothing"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNothing")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesRight"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesRight")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeVar"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeVar")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the usesEither field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataWithUsesEither :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata
pythonModuleMetadataWithUsesEither original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "namespaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "typeVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesAnnotated"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesAnnotated")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCallable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCallable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCast"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCast")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLruCache"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLruCache")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeAlias"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeAlias")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDataclass"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDataclass")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDecimal"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDecimal")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEither"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "usesEnum"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEnum")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenDict"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenDict")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenList"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenList")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenSet"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenSet")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesGeneric"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesGeneric")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesJust"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesJust")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLeft"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLeft")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesMaybe"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesMaybe")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNode"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNode")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNothing"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNothing")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesRight"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesRight")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeVar"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeVar")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the usesEnum field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataWithUsesEnum :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata
pythonModuleMetadataWithUsesEnum original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "namespaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "typeVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesAnnotated"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesAnnotated")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCallable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCallable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCast"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCast")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLruCache"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLruCache")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeAlias"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeAlias")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDataclass"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDataclass")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDecimal"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDecimal")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEither"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEither")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEnum"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenDict"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenDict")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenList"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenList")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenSet"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenSet")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesGeneric"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesGeneric")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesJust"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesJust")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLeft"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLeft")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesMaybe"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesMaybe")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNode"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNode")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNothing"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNothing")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesRight"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesRight")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeVar"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeVar")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the usesFrozenDict field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataWithUsesFrozenDict :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata
pythonModuleMetadataWithUsesFrozenDict original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "namespaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "typeVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesAnnotated"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesAnnotated")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCallable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCallable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCast"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCast")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLruCache"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLruCache")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeAlias"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeAlias")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDataclass"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDataclass")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDecimal"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDecimal")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEither"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEither")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEnum"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEnum")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenDict"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenList"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenList")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenSet"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenSet")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesGeneric"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesGeneric")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesJust"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesJust")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLeft"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLeft")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesMaybe"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesMaybe")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNode"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNode")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNothing"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNothing")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesRight"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesRight")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeVar"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeVar")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the usesFrozenList field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataWithUsesFrozenList :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata
pythonModuleMetadataWithUsesFrozenList original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "namespaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "typeVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesAnnotated"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesAnnotated")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCallable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCallable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCast"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCast")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLruCache"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLruCache")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeAlias"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeAlias")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDataclass"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDataclass")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDecimal"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDecimal")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEither"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEither")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEnum"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEnum")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenDict"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenDict")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenList"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenSet"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenSet")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesGeneric"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesGeneric")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesJust"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesJust")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLeft"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLeft")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesMaybe"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesMaybe")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNode"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNode")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNothing"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNothing")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesRight"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesRight")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeVar"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeVar")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the usesFrozenSet field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataWithUsesFrozenSet :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata
pythonModuleMetadataWithUsesFrozenSet original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "namespaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "typeVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesAnnotated"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesAnnotated")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCallable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCallable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCast"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCast")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLruCache"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLruCache")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeAlias"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeAlias")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDataclass"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDataclass")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDecimal"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDecimal")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEither"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEither")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEnum"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEnum")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenDict"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenDict")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenList"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenList")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenSet"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "usesGeneric"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesGeneric")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesJust"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesJust")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLeft"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLeft")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesMaybe"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesMaybe")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNode"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNode")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNothing"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNothing")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesRight"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesRight")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeVar"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeVar")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the usesGeneric field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataWithUsesGeneric :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata
pythonModuleMetadataWithUsesGeneric original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "namespaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "typeVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesAnnotated"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesAnnotated")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCallable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCallable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCast"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCast")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLruCache"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLruCache")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeAlias"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeAlias")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDataclass"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDataclass")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDecimal"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDecimal")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEither"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEither")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEnum"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEnum")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenDict"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenDict")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenList"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenList")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenSet"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenSet")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesGeneric"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "usesJust"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesJust")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLeft"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLeft")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesMaybe"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesMaybe")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNode"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNode")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNothing"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNothing")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesRight"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesRight")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeVar"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeVar")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the usesJust field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataWithUsesJust :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata
pythonModuleMetadataWithUsesJust original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "namespaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "typeVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesAnnotated"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesAnnotated")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCallable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCallable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCast"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCast")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLruCache"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLruCache")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeAlias"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeAlias")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDataclass"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDataclass")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDecimal"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDecimal")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEither"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEither")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEnum"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEnum")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenDict"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenDict")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenList"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenList")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenSet"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenSet")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesGeneric"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesGeneric")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesJust"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "usesLeft"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLeft")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesMaybe"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesMaybe")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNode"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNode")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNothing"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNothing")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesRight"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesRight")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeVar"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeVar")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the usesLeft field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataWithUsesLeft :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata
pythonModuleMetadataWithUsesLeft original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "namespaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "typeVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesAnnotated"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesAnnotated")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCallable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCallable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCast"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCast")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLruCache"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLruCache")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeAlias"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeAlias")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDataclass"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDataclass")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDecimal"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDecimal")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEither"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEither")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEnum"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEnum")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenDict"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenDict")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenList"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenList")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenSet"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenSet")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesGeneric"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesGeneric")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesJust"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesJust")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLeft"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "usesMaybe"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesMaybe")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNode"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNode")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNothing"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNothing")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesRight"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesRight")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeVar"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeVar")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the usesLruCache field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataWithUsesLruCache :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata
pythonModuleMetadataWithUsesLruCache original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "namespaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "typeVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesAnnotated"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesAnnotated")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCallable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCallable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCast"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCast")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLruCache"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeAlias"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeAlias")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDataclass"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDataclass")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDecimal"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDecimal")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEither"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEither")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEnum"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEnum")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenDict"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenDict")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenList"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenList")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenSet"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenSet")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesGeneric"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesGeneric")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesJust"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesJust")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLeft"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLeft")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesMaybe"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesMaybe")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNode"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNode")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNothing"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNothing")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesRight"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesRight")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeVar"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeVar")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the usesMaybe field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataWithUsesMaybe :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata
pythonModuleMetadataWithUsesMaybe original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "namespaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "typeVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesAnnotated"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesAnnotated")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCallable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCallable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCast"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCast")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLruCache"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLruCache")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeAlias"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeAlias")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDataclass"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDataclass")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDecimal"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDecimal")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEither"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEither")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEnum"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEnum")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenDict"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenDict")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenList"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenList")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenSet"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenSet")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesGeneric"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesGeneric")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesJust"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesJust")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLeft"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLeft")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesMaybe"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "usesName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNode"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNode")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNothing"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNothing")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesRight"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesRight")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeVar"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeVar")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the usesName field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataWithUsesName :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata
pythonModuleMetadataWithUsesName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "namespaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "typeVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesAnnotated"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesAnnotated")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCallable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCallable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCast"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCast")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLruCache"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLruCache")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeAlias"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeAlias")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDataclass"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDataclass")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDecimal"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDecimal")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEither"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEither")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEnum"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEnum")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenDict"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenDict")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenList"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenList")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenSet"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenSet")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesGeneric"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesGeneric")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesJust"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesJust")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLeft"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLeft")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesMaybe"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesMaybe")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesName"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "usesNode"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNode")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNothing"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNothing")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesRight"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesRight")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeVar"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeVar")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the usesNode field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataWithUsesNode :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata
pythonModuleMetadataWithUsesNode original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "namespaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "typeVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesAnnotated"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesAnnotated")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCallable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCallable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCast"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCast")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLruCache"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLruCache")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeAlias"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeAlias")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDataclass"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDataclass")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDecimal"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDecimal")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEither"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEither")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEnum"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEnum")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenDict"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenDict")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenList"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenList")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenSet"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenSet")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesGeneric"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesGeneric")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesJust"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesJust")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLeft"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLeft")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesMaybe"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesMaybe")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNode"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "usesNothing"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNothing")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesRight"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesRight")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeVar"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeVar")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the usesNothing field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataWithUsesNothing :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata
pythonModuleMetadataWithUsesNothing original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "namespaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "typeVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesAnnotated"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesAnnotated")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCallable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCallable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCast"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCast")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLruCache"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLruCache")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeAlias"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeAlias")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDataclass"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDataclass")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDecimal"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDecimal")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEither"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEither")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEnum"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEnum")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenDict"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenDict")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenList"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenList")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenSet"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenSet")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesGeneric"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesGeneric")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesJust"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesJust")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLeft"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLeft")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesMaybe"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesMaybe")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNode"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNode")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNothing"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "usesRight"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesRight")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeVar"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeVar")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the usesRight field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataWithUsesRight :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata
pythonModuleMetadataWithUsesRight original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "namespaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "typeVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesAnnotated"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesAnnotated")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCallable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCallable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCast"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCast")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLruCache"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLruCache")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeAlias"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeAlias")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDataclass"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDataclass")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDecimal"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDecimal")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEither"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEither")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEnum"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEnum")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenDict"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenDict")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenList"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenList")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenSet"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenSet")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesGeneric"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesGeneric")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesJust"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesJust")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLeft"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLeft")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesMaybe"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesMaybe")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNode"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNode")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNothing"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNothing")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesRight"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeVar"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeVar")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the usesTypeAlias field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataWithUsesTypeAlias :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata
pythonModuleMetadataWithUsesTypeAlias original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "namespaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "typeVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesAnnotated"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesAnnotated")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCallable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCallable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCast"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCast")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLruCache"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLruCache")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeAlias"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "usesDataclass"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDataclass")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDecimal"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDecimal")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEither"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEither")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEnum"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEnum")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenDict"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenDict")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenList"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenList")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenSet"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenSet")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesGeneric"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesGeneric")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesJust"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesJust")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLeft"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLeft")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesMaybe"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesMaybe")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNode"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNode")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNothing"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNothing")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesRight"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesRight")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeVar"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeVar")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the usesTypeVar field of hydra.python.environment.PythonModuleMetadata
pythonModuleMetadataWithUsesTypeVar :: Typed.TypedTerm Environment.PythonModuleMetadata -> Typed.TypedTerm Bool -> Typed.TypedTerm Environment.PythonModuleMetadata
pythonModuleMetadataWithUsesTypeVar original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespaces"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "namespaces")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "typeVariables"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "typeVariables")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesAnnotated"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesAnnotated")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCallable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCallable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesCast"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesCast")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLruCache"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLruCache")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeAlias"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesTypeAlias")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDataclass"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDataclass")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesDecimal"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesDecimal")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEither"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEither")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesEnum"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesEnum")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenDict"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenDict")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenList"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenList")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesFrozenSet"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesFrozenSet")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesGeneric"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesGeneric")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesJust"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesJust")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesLeft"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesLeft")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesMaybe"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesMaybe")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNode"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNode")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesNothing"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesNothing")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesRight"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.python.environment.PythonModuleMetadata"),
              Model.projectionFieldName = (Model.Name "usesRight")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "usesTypeVar"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the python310 variant of hydra.python.environment.PythonVersion
pythonVersionPython310 :: Typed.TypedTerm Environment.PythonVersion
pythonVersionPython310 =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.python.environment.PythonVersion"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "python310"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the python312 variant of hydra.python.environment.PythonVersion
pythonVersionPython312 :: Typed.TypedTerm Environment.PythonVersion
pythonVersionPython312 =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.python.environment.PythonVersion"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "python312"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.python.environment.PythonVersion
pythonVersionPythonVersion :: Typed.TypedName Environment.PythonVersion
pythonVersionPythonVersion = Typed.TypedName (Model.Name "hydra.python.environment.PythonVersion")