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

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

-- | Term encoders for hydra.build.format

module Hydra.Encode.Build.Format where

import qualified Hydra.Build.Format as Format
import qualified Hydra.Core as Core
import qualified Hydra.Encode.Packaging as Packaging
import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists
import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps
import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
import qualified Data.Scientific as Sci

-- | Encoder for hydra.build.format.DefinitionNameConventionProfile
definitionNameConventionProfile :: Format.DefinitionNameConventionProfile -> Core.Term
definitionNameConventionProfile x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionNameConventionProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "severity"),
          Core.fieldTerm = (severity (Format.definitionNameConventionProfileSeverity x))},
        Core.Field {
          Core.fieldName = (Core.Name "allowUnderscores"),
          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralBoolean x2)) (Format.definitionNameConventionProfileAllowUnderscores x))}]})

-- | Encoder for hydra.build.format.DefinitionValidationProfile
definitionValidationProfile :: Format.DefinitionValidationProfile -> Core.Term
definitionValidationProfile x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.DefinitionValidationProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "hasDescription"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map documentationProfile opt)) (Format.definitionValidationProfileHasDescription x))},
        Core.Field {
          Core.fieldName = (Core.Name "ordering"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.definitionValidationProfileOrdering x))},
        Core.Field {
          Core.fieldName = (Core.Name "nameConvention"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map definitionNameConventionProfile opt)) (Format.definitionValidationProfileNameConvention x))},
        Core.Field {
          Core.fieldName = (Core.Name "notInModuleName"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.definitionValidationProfileNotInModuleName x))},
        Core.Field {
          Core.fieldName = (Core.Name "duplicateName"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.definitionValidationProfileDuplicateName x))}]})

-- | Encoder for hydra.build.format.DigestEntry
digestEntry :: Format.DigestEntry -> Core.Term
digestEntry x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.DigestEntry"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "kind"),
          Core.fieldTerm = (digestKind (Format.digestEntryKind x))},
        Core.Field {
          Core.fieldName = (Core.Name "hash"),
          Core.fieldTerm = (sha256Hash (Format.digestEntryHash x))}]})

-- | Encoder for hydra.build.format.DigestKind
digestKind :: Format.DigestKind -> Core.Term
digestKind x =
    case x of
      Format.DigestKindDslSource -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.build.format.DigestKind"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "dslSource"),
          Core.fieldTerm = Core.TermUnit}})
      Format.DigestKindJsonFile -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.build.format.DigestKind"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "jsonFile"),
          Core.fieldTerm = Core.TermUnit}})
      Format.DigestKindTargetFile -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.build.format.DigestKind"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "targetFile"),
          Core.fieldTerm = Core.TermUnit}})
      Format.DigestKindRuntimeFile -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.build.format.DigestKind"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "runtimeFile"),
          Core.fieldTerm = Core.TermUnit}})
      Format.DigestKindOther -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.build.format.DigestKind"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "other"),
          Core.fieldTerm = Core.TermUnit}})

-- | Encoder for hydra.build.format.DocumentationProfile
documentationProfile :: Format.DocumentationProfile -> Core.Term
documentationProfile x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.DocumentationProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "severity"),
          Core.fieldTerm = (severity (Format.documentationProfileSeverity x))},
        Core.Field {
          Core.fieldName = (Core.Name "exemptDeprecated"),
          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralBoolean x2)) (Format.documentationProfileExemptDeprecated x))}]})

-- | Encoder for hydra.build.format.Generation
generation :: Format.Generation -> Core.Term
generation x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.Generation"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "generatorId"),
          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.generationGeneratorId x))},
        Core.Field {
          Core.fieldName = (Core.Name "mode"),
          Core.fieldTerm = (generationMode (Format.generationMode x))},
        Core.Field {
          Core.fieldName = (Core.Name "host"),
          Core.fieldTerm = (languageName (Format.generationHost x))},
        Core.Field {
          Core.fieldName = (Core.Name "hydraVersion"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map Packaging.version opt)) (Format.generationHydraVersion x))},
        Core.Field {
          Core.fieldName = (Core.Name "revision"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map (\x2 -> Core.TermLiteral (Core.LiteralString x2)) opt)) (Format.generationRevision x))},
        Core.Field {
          Core.fieldName = (Core.Name "timestamp"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map (\x2 -> Core.TermLiteral (Core.LiteralString x2)) opt)) (Format.generationTimestamp x))}]})

-- | Encoder for hydra.build.format.GenerationMode
generationMode :: Format.GenerationMode -> Core.Term
generationMode x =
    case x of
      Format.GenerationModePublished -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.build.format.GenerationMode"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "published"),
          Core.fieldTerm = Core.TermUnit}})
      Format.GenerationModeShim -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.build.format.GenerationMode"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "shim"),
          Core.fieldTerm = Core.TermUnit}})

-- | Encoder for hydra.build.format.HostOverride
hostOverride :: Format.HostOverride -> Core.Term
hostOverride x =
    case x of
      Format.HostOverrideLocal -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.build.format.HostOverride"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "local"),
          Core.fieldTerm = Core.TermUnit}})
      Format.HostOverrideVersion v0 -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.build.format.HostOverride"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "version"),
          Core.fieldTerm = (Packaging.version v0)}})

-- | Encoder for hydra.build.format.InputDigest
inputDigest :: Format.InputDigest -> Core.Term
inputDigest x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.InputDigest"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "digestFormatVersion"),
          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Format.inputDigestDigestFormatVersion x))},
        Core.Field {
          Core.fieldName = (Core.Name "moduleFormatVersion"),
          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Format.inputDigestModuleFormatVersion x))},
        Core.Field {
          Core.fieldName = (Core.Name "selfHash"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map sha256Hash opt)) (Format.inputDigestSelfHash x))},
        Core.Field {
          Core.fieldName = (Core.Name "dependencyHashes"),
          Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap Packaging.packageName sha256Hash m)) (Format.inputDigestDependencyHashes x))},
        Core.Field {
          Core.fieldName = (Core.Name "moduleHashes"),
          Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap Packaging.moduleName sha256Hash m)) (Format.inputDigestModuleHashes x))}]})

-- | Encoder for hydra.build.format.LanguageName
languageName :: Format.LanguageName -> Core.Term
languageName x =
    Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.build.format.LanguageName"),
      Core.wrappedTermBody = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.unLanguageName x))})

-- | Encoder for hydra.build.format.ModuleValidationProfile
moduleValidationProfile :: Format.ModuleValidationProfile -> Core.Term
moduleValidationProfile x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.ModuleValidationProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "definitions"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map definitionValidationProfile opt)) (Format.moduleValidationProfileDefinitions x))},
        Core.Field {
          Core.fieldName = (Core.Name "nameConvention"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.moduleValidationProfileNameConvention x))},
        Core.Field {
          Core.fieldName = (Core.Name "conflictingVariantName"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.moduleValidationProfileConflictingVariantName x))}]})

-- | Encoder for hydra.build.format.OutputDigest
outputDigest :: Format.OutputDigest -> Core.Term
outputDigest x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.OutputDigest"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "digestFormatVersion"),
          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Format.outputDigestDigestFormatVersion x))},
        Core.Field {
          Core.fieldName = (Core.Name "moduleFormatVersion"),
          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Format.outputDigestModuleFormatVersion x))},
        Core.Field {
          Core.fieldName = (Core.Name "generator"),
          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.outputDigestGenerator x))},
        Core.Field {
          Core.fieldName = (Core.Name "generation"),
          Core.fieldTerm = (generation (Format.outputDigestGeneration x))},
        Core.Field {
          Core.fieldName = (Core.Name "selfHash"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map sha256Hash opt)) (Format.outputDigestSelfHash x))},
        Core.Field {
          Core.fieldName = (Core.Name "dependencyHashes"),
          Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap Packaging.packageName sha256Hash m)) (Format.outputDigestDependencyHashes x))},
        Core.Field {
          Core.fieldName = (Core.Name "inputs"),
          Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap (\x2 -> Core.TermLiteral (Core.LiteralString x2)) digestEntry m)) (Format.outputDigestInputs x))},
        Core.Field {
          Core.fieldName = (Core.Name "outputs"),
          Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap (\x2 -> Core.TermLiteral (Core.LiteralString x2)) digestEntry m)) (Format.outputDigestOutputs x))}]})

-- | Encoder for hydra.build.format.PackageDescriptor
packageDescriptor :: Format.PackageDescriptor -> Core.Term
packageDescriptor x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.PackageDescriptor"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "packageFormatVersion"),
          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Format.packageDescriptorPackageFormatVersion x))},
        Core.Field {
          Core.fieldName = (Core.Name "name"),
          Core.fieldTerm = (Packaging.packageName (Format.packageDescriptorName x))},
        Core.Field {
          Core.fieldName = (Core.Name "description"),
          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.packageDescriptorDescription x))},
        Core.Field {
          Core.fieldName = (Core.Name "sourceLanguage"),
          Core.fieldTerm = (languageName (Format.packageDescriptorSourceLanguage x))},
        Core.Field {
          Core.fieldName = (Core.Name "targetLanguages"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map (\xs -> Core.TermList (Lists.map languageName xs)) opt)) (Format.packageDescriptorTargetLanguages x))},
        Core.Field {
          Core.fieldName = (Core.Name "dependencies"),
          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map Packaging.packageName xs)) (Format.packageDescriptorDependencies x))},
        Core.Field {
          Core.fieldName = (Core.Name "validation"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map packageValidationConfiguration opt)) (Format.packageDescriptorValidation x))}]})

-- | Encoder for hydra.build.format.PackageManifest
packageManifest :: Format.PackageManifest -> Core.Term
packageManifest x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.PackageManifest"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "manifestFormatVersion"),
          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Format.packageManifestManifestFormatVersion x))},
        Core.Field {
          Core.fieldName = (Core.Name "moduleFormatVersion"),
          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Format.packageManifestModuleFormatVersion x))},
        Core.Field {
          Core.fieldName = (Core.Name "package"),
          Core.fieldTerm = (Packaging.packageName (Format.packageManifestPackage x))},
        Core.Field {
          Core.fieldName = (Core.Name "mainModules"),
          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map Packaging.moduleName xs)) (Format.packageManifestMainModules x))},
        Core.Field {
          Core.fieldName = (Core.Name "testModules"),
          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map Packaging.moduleName xs)) (Format.packageManifestTestModules x))},
        Core.Field {
          Core.fieldName = (Core.Name "mainDslModules"),
          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map Packaging.moduleName xs)) (Format.packageManifestMainDslModules x))},
        Core.Field {
          Core.fieldName = (Core.Name "mainEncodingModules"),
          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map Packaging.moduleName xs)) (Format.packageManifestMainEncodingModules x))}]})

-- | Encoder for hydra.build.format.PackageValidationConfiguration
packageValidationConfiguration :: Format.PackageValidationConfiguration -> Core.Term
packageValidationConfiguration x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationConfiguration"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "package"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map packageValidationProfile opt)) (Format.packageValidationConfigurationPackage x))},
        Core.Field {
          Core.fieldName = (Core.Name "module"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map moduleValidationProfile opt)) (Format.packageValidationConfigurationModule x))},
        Core.Field {
          Core.fieldName = (Core.Name "type"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map typeValidationProfile opt)) (Format.packageValidationConfigurationType x))},
        Core.Field {
          Core.fieldName = (Core.Name "term"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map termValidationProfile opt)) (Format.packageValidationConfigurationTerm x))}]})

-- | Encoder for hydra.build.format.PackageValidationProfile
packageValidationProfile :: Format.PackageValidationProfile -> Core.Term
packageValidationProfile x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.PackageValidationProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "conflictingModuleName"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.packageValidationProfileConflictingModuleName x))},
        Core.Field {
          Core.fieldName = (Core.Name "duplicateModuleName"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.packageValidationProfileDuplicateModuleName x))},
        Core.Field {
          Core.fieldName = (Core.Name "nameConvention"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.packageValidationProfileNameConvention x))}]})

-- | Encoder for hydra.build.format.RepositoryDescriptor
repositoryDescriptor :: Format.RepositoryDescriptor -> Core.Term
repositoryDescriptor x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.RepositoryDescriptor"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "currentVersion"),
          Core.fieldTerm = (Packaging.version (Format.repositoryDescriptorCurrentVersion x))},
        Core.Field {
          Core.fieldName = (Core.Name "hostVersion"),
          Core.fieldTerm = (Packaging.version (Format.repositoryDescriptorHostVersion x))},
        Core.Field {
          Core.fieldName = (Core.Name "hostOverrides"),
          Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap languageName hostOverride m)) (Format.repositoryDescriptorHostOverrides x))},
        Core.Field {
          Core.fieldName = (Core.Name "group"),
          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.repositoryDescriptorGroup x))},
        Core.Field {
          Core.fieldName = (Core.Name "author"),
          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.repositoryDescriptorAuthor x))},
        Core.Field {
          Core.fieldName = (Core.Name "url"),
          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.repositoryDescriptorUrl x))},
        Core.Field {
          Core.fieldName = (Core.Name "license"),
          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.repositoryDescriptorLicense x))},
        Core.Field {
          Core.fieldName = (Core.Name "packages"),
          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map Packaging.packageName xs)) (Format.repositoryDescriptorPackages x))}]})

-- | Encoder for hydra.build.format.Severity
severity :: Format.Severity -> Core.Term
severity x =
    case x of
      Format.SeverityError -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.build.format.Severity"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "error"),
          Core.fieldTerm = Core.TermUnit}})
      Format.SeverityWarning -> Core.TermInject (Core.Injection {
        Core.injectionTypeName = (Core.Name "hydra.build.format.Severity"),
        Core.injectionField = Core.Field {
          Core.fieldName = (Core.Name "warning"),
          Core.fieldTerm = Core.TermUnit}})

-- | Encoder for hydra.build.format.Sha256Hash
sha256Hash :: Format.Sha256Hash -> Core.Term
sha256Hash x =
    Core.TermWrap (Core.WrappedTerm {
      Core.wrappedTermTypeName = (Core.Name "hydra.build.format.Sha256Hash"),
      Core.wrappedTermBody = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.unSha256Hash x))})

-- | Encoder for hydra.build.format.TermValidationProfile
termValidationProfile :: Format.TermValidationProfile -> Core.Term
termValidationProfile x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.TermValidationProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "duplicateBinding"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.termValidationProfileDuplicateBinding x))},
        Core.Field {
          Core.fieldName = (Core.Name "emptyTermAnnotation"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.termValidationProfileEmptyTermAnnotation x))},
        Core.Field {
          Core.fieldName = (Core.Name "undefinedVariable"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.termValidationProfileUndefinedVariable x))}]})

-- | Encoder for hydra.build.format.TypeValidationProfile
typeValidationProfile :: Format.TypeValidationProfile -> Core.Term
typeValidationProfile x =
    Core.TermRecord (Core.Record {
      Core.recordTypeName = (Core.Name "hydra.build.format.TypeValidationProfile"),
      Core.recordFields = [
        Core.Field {
          Core.fieldName = (Core.Name "emptyAnnotation"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.typeValidationProfileEmptyAnnotation x))},
        Core.Field {
          Core.fieldName = (Core.Name "duplicateField"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.typeValidationProfileDuplicateField x))},
        Core.Field {
          Core.fieldName = (Core.Name "singleVariantUnion"),
          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map severity opt)) (Format.typeValidationProfileSingleVariantUnion x))}]})