hydra-ext-0.18.0: src/main/haskell/Hydra/Ext/Dsl/Avro/Testing.hs

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

-- | DSL functions for hydra.ext.avro.testing

module Hydra.Ext.Dsl.Avro.Testing where

import qualified Hydra.Core.Json.Model as JsonModel
import qualified Hydra.Core.Model as Model
import qualified Hydra.Core.Typed as Typed
import qualified Hydra.Ext.Avro.Schema as Schema
import qualified Hydra.Ext.Avro.Testing as Testing
import qualified Hydra.Ext.Dsl.Avro.Schema as AvroSchema
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
import qualified Data.Scientific as Sci
import Data.Void

-- | DSL name token for hydra.ext.avro.testing.AvroTestCase
avroTestCaseAvroTestCase :: Typed.TypedName Testing.AvroTestCase
avroTestCaseAvroTestCase = Typed.TypedName (Model.Name "hydra.ext.avro.testing.AvroTestCase")

-- | DSL injection for the lossiness variant of hydra.ext.avro.testing.AvroTestCase
avroTestCaseLossiness :: Typed.TypedTerm Testing.LossinessTestCase -> Typed.TypedTerm Testing.AvroTestCase
avroTestCaseLossiness x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.testing.AvroTestCase"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "lossiness"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the nameMapping variant of hydra.ext.avro.testing.AvroTestCase
avroTestCaseNameMapping :: Typed.TypedTerm Testing.NameMappingTestCase -> Typed.TypedTerm Testing.AvroTestCase
avroTestCaseNameMapping x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.testing.AvroTestCase"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "nameMapping"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the schemaSerialization variant of hydra.ext.avro.testing.AvroTestCase
avroTestCaseSchemaSerialization :: Typed.TypedTerm Testing.SchemaSerializationTestCase -> Typed.TypedTerm Testing.AvroTestCase
avroTestCaseSchemaSerialization x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.testing.AvroTestCase"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "schemaSerialization"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the termLevelForward variant of hydra.ext.avro.testing.AvroTestCase
avroTestCaseTermLevelForward :: Typed.TypedTerm Testing.TermLevelForwardTestCase -> Typed.TypedTerm Testing.AvroTestCase
avroTestCaseTermLevelForward x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.testing.AvroTestCase"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "termLevelForward"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the termLevelReverse variant of hydra.ext.avro.testing.AvroTestCase
avroTestCaseTermLevelReverse :: Typed.TypedTerm Testing.TermLevelReverseTestCase -> Typed.TypedTerm Testing.AvroTestCase
avroTestCaseTermLevelReverse x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.testing.AvroTestCase"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "termLevelReverse"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the termLevelRoundTripJson variant of hydra.ext.avro.testing.AvroTestCase
avroTestCaseTermLevelRoundTripJson :: Typed.TypedTerm Testing.TermLevelRoundTripJsonTestCase -> Typed.TypedTerm Testing.AvroTestCase
avroTestCaseTermLevelRoundTripJson x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.testing.AvroTestCase"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "termLevelRoundTripJson"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the termLevelRoundTripTerm variant of hydra.ext.avro.testing.AvroTestCase
avroTestCaseTermLevelRoundTripTerm :: Typed.TypedTerm Testing.TermLevelRoundTripTermTestCase -> Typed.TypedTerm Testing.AvroTestCase
avroTestCaseTermLevelRoundTripTerm x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.testing.AvroTestCase"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "termLevelRoundTripTerm"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the typeLevelForward variant of hydra.ext.avro.testing.AvroTestCase
avroTestCaseTypeLevelForward :: Typed.TypedTerm Testing.TypeLevelForwardTestCase -> Typed.TypedTerm Testing.AvroTestCase
avroTestCaseTypeLevelForward x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.testing.AvroTestCase"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "typeLevelForward"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the typeLevelReverse variant of hydra.ext.avro.testing.AvroTestCase
avroTestCaseTypeLevelReverse :: Typed.TypedTerm Testing.TypeLevelReverseTestCase -> Typed.TypedTerm Testing.AvroTestCase
avroTestCaseTypeLevelReverse x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.testing.AvroTestCase"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "typeLevelReverse"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the typeLevelRoundTripAvro variant of hydra.ext.avro.testing.AvroTestCase
avroTestCaseTypeLevelRoundTripAvro :: Typed.TypedTerm Testing.TypeLevelRoundTripAvroTestCase -> Typed.TypedTerm Testing.AvroTestCase
avroTestCaseTypeLevelRoundTripAvro x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.testing.AvroTestCase"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "typeLevelRoundTripAvro"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the typeLevelRoundTripHydra variant of hydra.ext.avro.testing.AvroTestCase
avroTestCaseTypeLevelRoundTripHydra :: Typed.TypedTerm Testing.TypeLevelRoundTripHydraTestCase -> Typed.TypedTerm Testing.AvroTestCase
avroTestCaseTypeLevelRoundTripHydra x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.testing.AvroTestCase"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "typeLevelRoundTripHydra"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the union variant of hydra.ext.avro.testing.AvroTestCase
avroTestCaseUnion :: Typed.TypedTerm Testing.UnionTestCase -> Typed.TypedTerm Testing.AvroTestCase
avroTestCaseUnion x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.testing.AvroTestCase"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "union"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.avro.testing.LossinessTestCase
lossinessTestCase :: Typed.TypedTerm String -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Bool -> Typed.TypedTerm Testing.LossinessTestCase
lossinessTestCase description originalSchema hydraType recoveredSchema isLossy =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm description)},
        Model.Field {
          Model.fieldName = (Model.Name "originalSchema"),
          Model.fieldTerm = (Typed.unTypedTerm originalSchema)},
        Model.Field {
          Model.fieldName = (Model.Name "hydraType"),
          Model.fieldTerm = (Typed.unTypedTerm hydraType)},
        Model.Field {
          Model.fieldName = (Model.Name "recoveredSchema"),
          Model.fieldTerm = (Typed.unTypedTerm recoveredSchema)},
        Model.Field {
          Model.fieldName = (Model.Name "isLossy"),
          Model.fieldTerm = (Typed.unTypedTerm isLossy)}]}))

-- | DSL accessor for the description field of hydra.ext.avro.testing.LossinessTestCase
lossinessTestCaseDescription :: Typed.TypedTerm Testing.LossinessTestCase -> Typed.TypedTerm String
lossinessTestCaseDescription x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"),
        Model.projectionFieldName = (Model.Name "description")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the hydraType field of hydra.ext.avro.testing.LossinessTestCase
lossinessTestCaseHydraType :: Typed.TypedTerm Testing.LossinessTestCase -> Typed.TypedTerm Model.Type
lossinessTestCaseHydraType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"),
        Model.projectionFieldName = (Model.Name "hydraType")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the isLossy field of hydra.ext.avro.testing.LossinessTestCase
lossinessTestCaseIsLossy :: Typed.TypedTerm Testing.LossinessTestCase -> Typed.TypedTerm Bool
lossinessTestCaseIsLossy x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"),
        Model.projectionFieldName = (Model.Name "isLossy")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.avro.testing.LossinessTestCase
lossinessTestCaseLossinessTestCase :: Typed.TypedName Testing.LossinessTestCase
lossinessTestCaseLossinessTestCase = Typed.TypedName (Model.Name "hydra.ext.avro.testing.LossinessTestCase")

-- | DSL accessor for the originalSchema field of hydra.ext.avro.testing.LossinessTestCase
lossinessTestCaseOriginalSchema :: Typed.TypedTerm Testing.LossinessTestCase -> Typed.TypedTerm Schema.Schema
lossinessTestCaseOriginalSchema x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"),
        Model.projectionFieldName = (Model.Name "originalSchema")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the recoveredSchema field of hydra.ext.avro.testing.LossinessTestCase
lossinessTestCaseRecoveredSchema :: Typed.TypedTerm Testing.LossinessTestCase -> Typed.TypedTerm Schema.Schema
lossinessTestCaseRecoveredSchema x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"),
        Model.projectionFieldName = (Model.Name "recoveredSchema")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the description field of hydra.ext.avro.testing.LossinessTestCase
lossinessTestCaseWithDescription :: Typed.TypedTerm Testing.LossinessTestCase -> Typed.TypedTerm String -> Typed.TypedTerm Testing.LossinessTestCase
lossinessTestCaseWithDescription original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "originalSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"),
              Model.projectionFieldName = (Model.Name "originalSchema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "hydraType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"),
              Model.projectionFieldName = (Model.Name "hydraType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "recoveredSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"),
              Model.projectionFieldName = (Model.Name "recoveredSchema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "isLossy"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"),
              Model.projectionFieldName = (Model.Name "isLossy")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the hydraType field of hydra.ext.avro.testing.LossinessTestCase
lossinessTestCaseWithHydraType :: Typed.TypedTerm Testing.LossinessTestCase -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Testing.LossinessTestCase
lossinessTestCaseWithHydraType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "originalSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"),
              Model.projectionFieldName = (Model.Name "originalSchema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "hydraType"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "recoveredSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"),
              Model.projectionFieldName = (Model.Name "recoveredSchema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "isLossy"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"),
              Model.projectionFieldName = (Model.Name "isLossy")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the isLossy field of hydra.ext.avro.testing.LossinessTestCase
lossinessTestCaseWithIsLossy :: Typed.TypedTerm Testing.LossinessTestCase -> Typed.TypedTerm Bool -> Typed.TypedTerm Testing.LossinessTestCase
lossinessTestCaseWithIsLossy original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "originalSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"),
              Model.projectionFieldName = (Model.Name "originalSchema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "hydraType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"),
              Model.projectionFieldName = (Model.Name "hydraType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "recoveredSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"),
              Model.projectionFieldName = (Model.Name "recoveredSchema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "isLossy"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the originalSchema field of hydra.ext.avro.testing.LossinessTestCase
lossinessTestCaseWithOriginalSchema :: Typed.TypedTerm Testing.LossinessTestCase -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Testing.LossinessTestCase
lossinessTestCaseWithOriginalSchema original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "originalSchema"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "hydraType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"),
              Model.projectionFieldName = (Model.Name "hydraType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "recoveredSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"),
              Model.projectionFieldName = (Model.Name "recoveredSchema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "isLossy"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"),
              Model.projectionFieldName = (Model.Name "isLossy")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the recoveredSchema field of hydra.ext.avro.testing.LossinessTestCase
lossinessTestCaseWithRecoveredSchema :: Typed.TypedTerm Testing.LossinessTestCase -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Testing.LossinessTestCase
lossinessTestCaseWithRecoveredSchema original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "originalSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"),
              Model.projectionFieldName = (Model.Name "originalSchema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "hydraType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"),
              Model.projectionFieldName = (Model.Name "hydraType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "recoveredSchema"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "isLossy"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.LossinessTestCase"),
              Model.projectionFieldName = (Model.Name "isLossy")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.avro.testing.NameMappingTestCase
nameMappingTestCase :: Typed.TypedTerm String -> Typed.TypedTerm Model.Name -> Typed.TypedTerm String -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Testing.NameMappingTestCase
nameMappingTestCase description hydraName avroName avroNamespace =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm description)},
        Model.Field {
          Model.fieldName = (Model.Name "hydraName"),
          Model.fieldTerm = (Typed.unTypedTerm hydraName)},
        Model.Field {
          Model.fieldName = (Model.Name "avroName"),
          Model.fieldTerm = (Typed.unTypedTerm avroName)},
        Model.Field {
          Model.fieldName = (Model.Name "avroNamespace"),
          Model.fieldTerm = (Typed.unTypedTerm avroNamespace)}]}))

-- | DSL accessor for the avroName field of hydra.ext.avro.testing.NameMappingTestCase
nameMappingTestCaseAvroName :: Typed.TypedTerm Testing.NameMappingTestCase -> Typed.TypedTerm String
nameMappingTestCaseAvroName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"),
        Model.projectionFieldName = (Model.Name "avroName")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the avroNamespace field of hydra.ext.avro.testing.NameMappingTestCase
nameMappingTestCaseAvroNamespace :: Typed.TypedTerm Testing.NameMappingTestCase -> Typed.TypedTerm (Maybe String)
nameMappingTestCaseAvroNamespace x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"),
        Model.projectionFieldName = (Model.Name "avroNamespace")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the description field of hydra.ext.avro.testing.NameMappingTestCase
nameMappingTestCaseDescription :: Typed.TypedTerm Testing.NameMappingTestCase -> Typed.TypedTerm String
nameMappingTestCaseDescription x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"),
        Model.projectionFieldName = (Model.Name "description")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the hydraName field of hydra.ext.avro.testing.NameMappingTestCase
nameMappingTestCaseHydraName :: Typed.TypedTerm Testing.NameMappingTestCase -> Typed.TypedTerm Model.Name
nameMappingTestCaseHydraName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"),
        Model.projectionFieldName = (Model.Name "hydraName")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.avro.testing.NameMappingTestCase
nameMappingTestCaseNameMappingTestCase :: Typed.TypedName Testing.NameMappingTestCase
nameMappingTestCaseNameMappingTestCase = Typed.TypedName (Model.Name "hydra.ext.avro.testing.NameMappingTestCase")

-- | DSL updater for the avroName field of hydra.ext.avro.testing.NameMappingTestCase
nameMappingTestCaseWithAvroName :: Typed.TypedTerm Testing.NameMappingTestCase -> Typed.TypedTerm String -> Typed.TypedTerm Testing.NameMappingTestCase
nameMappingTestCaseWithAvroName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "hydraName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"),
              Model.projectionFieldName = (Model.Name "hydraName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "avroName"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "avroNamespace"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"),
              Model.projectionFieldName = (Model.Name "avroNamespace")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the avroNamespace field of hydra.ext.avro.testing.NameMappingTestCase
nameMappingTestCaseWithAvroNamespace :: Typed.TypedTerm Testing.NameMappingTestCase -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Testing.NameMappingTestCase
nameMappingTestCaseWithAvroNamespace original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "hydraName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"),
              Model.projectionFieldName = (Model.Name "hydraName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "avroName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"),
              Model.projectionFieldName = (Model.Name "avroName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "avroNamespace"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the description field of hydra.ext.avro.testing.NameMappingTestCase
nameMappingTestCaseWithDescription :: Typed.TypedTerm Testing.NameMappingTestCase -> Typed.TypedTerm String -> Typed.TypedTerm Testing.NameMappingTestCase
nameMappingTestCaseWithDescription original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "hydraName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"),
              Model.projectionFieldName = (Model.Name "hydraName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "avroName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"),
              Model.projectionFieldName = (Model.Name "avroName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "avroNamespace"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"),
              Model.projectionFieldName = (Model.Name "avroNamespace")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the hydraName field of hydra.ext.avro.testing.NameMappingTestCase
nameMappingTestCaseWithHydraName :: Typed.TypedTerm Testing.NameMappingTestCase -> Typed.TypedTerm Model.Name -> Typed.TypedTerm Testing.NameMappingTestCase
nameMappingTestCaseWithHydraName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "hydraName"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "avroName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"),
              Model.projectionFieldName = (Model.Name "avroName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "avroNamespace"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.NameMappingTestCase"),
              Model.projectionFieldName = (Model.Name "avroNamespace")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.avro.testing.SchemaSerializationTestCase
schemaSerializationTestCase :: Typed.TypedTerm String -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm JsonModel.Value -> Typed.TypedTerm Testing.SchemaSerializationTestCase
schemaSerializationTestCase description schema json =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.SchemaSerializationTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm description)},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Typed.unTypedTerm schema)},
        Model.Field {
          Model.fieldName = (Model.Name "json"),
          Model.fieldTerm = (Typed.unTypedTerm json)}]}))

-- | DSL accessor for the description field of hydra.ext.avro.testing.SchemaSerializationTestCase
schemaSerializationTestCaseDescription :: Typed.TypedTerm Testing.SchemaSerializationTestCase -> Typed.TypedTerm String
schemaSerializationTestCaseDescription x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.SchemaSerializationTestCase"),
        Model.projectionFieldName = (Model.Name "description")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the json field of hydra.ext.avro.testing.SchemaSerializationTestCase
schemaSerializationTestCaseJson :: Typed.TypedTerm Testing.SchemaSerializationTestCase -> Typed.TypedTerm JsonModel.Value
schemaSerializationTestCaseJson x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.SchemaSerializationTestCase"),
        Model.projectionFieldName = (Model.Name "json")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the schema field of hydra.ext.avro.testing.SchemaSerializationTestCase
schemaSerializationTestCaseSchema :: Typed.TypedTerm Testing.SchemaSerializationTestCase -> Typed.TypedTerm Schema.Schema
schemaSerializationTestCaseSchema x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.SchemaSerializationTestCase"),
        Model.projectionFieldName = (Model.Name "schema")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.avro.testing.SchemaSerializationTestCase
schemaSerializationTestCaseSchemaSerializationTestCase :: Typed.TypedName Testing.SchemaSerializationTestCase
schemaSerializationTestCaseSchemaSerializationTestCase =
    Typed.TypedName (Model.Name "hydra.ext.avro.testing.SchemaSerializationTestCase")

-- | DSL updater for the description field of hydra.ext.avro.testing.SchemaSerializationTestCase
schemaSerializationTestCaseWithDescription :: Typed.TypedTerm Testing.SchemaSerializationTestCase -> Typed.TypedTerm String -> Typed.TypedTerm Testing.SchemaSerializationTestCase
schemaSerializationTestCaseWithDescription original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.SchemaSerializationTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.SchemaSerializationTestCase"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "json"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.SchemaSerializationTestCase"),
              Model.projectionFieldName = (Model.Name "json")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the json field of hydra.ext.avro.testing.SchemaSerializationTestCase
schemaSerializationTestCaseWithJson :: Typed.TypedTerm Testing.SchemaSerializationTestCase -> Typed.TypedTerm JsonModel.Value -> Typed.TypedTerm Testing.SchemaSerializationTestCase
schemaSerializationTestCaseWithJson original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.SchemaSerializationTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.SchemaSerializationTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.SchemaSerializationTestCase"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "json"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the schema field of hydra.ext.avro.testing.SchemaSerializationTestCase
schemaSerializationTestCaseWithSchema :: Typed.TypedTerm Testing.SchemaSerializationTestCase -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Testing.SchemaSerializationTestCase
schemaSerializationTestCaseWithSchema original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.SchemaSerializationTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.SchemaSerializationTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "json"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.SchemaSerializationTestCase"),
              Model.projectionFieldName = (Model.Name "json")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.avro.testing.TermLevelForwardTestCase
termLevelForwardTestCase :: Typed.TypedTerm String -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm JsonModel.Value -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Testing.TermLevelForwardTestCase
termLevelForwardTestCase description schema json term =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm description)},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Typed.unTypedTerm schema)},
        Model.Field {
          Model.fieldName = (Model.Name "json"),
          Model.fieldTerm = (Typed.unTypedTerm json)},
        Model.Field {
          Model.fieldName = (Model.Name "term"),
          Model.fieldTerm = (Typed.unTypedTerm term)}]}))

-- | DSL accessor for the description field of hydra.ext.avro.testing.TermLevelForwardTestCase
termLevelForwardTestCaseDescription :: Typed.TypedTerm Testing.TermLevelForwardTestCase -> Typed.TypedTerm String
termLevelForwardTestCaseDescription x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"),
        Model.projectionFieldName = (Model.Name "description")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the json field of hydra.ext.avro.testing.TermLevelForwardTestCase
termLevelForwardTestCaseJson :: Typed.TypedTerm Testing.TermLevelForwardTestCase -> Typed.TypedTerm JsonModel.Value
termLevelForwardTestCaseJson x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"),
        Model.projectionFieldName = (Model.Name "json")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the schema field of hydra.ext.avro.testing.TermLevelForwardTestCase
termLevelForwardTestCaseSchema :: Typed.TypedTerm Testing.TermLevelForwardTestCase -> Typed.TypedTerm Schema.Schema
termLevelForwardTestCaseSchema x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"),
        Model.projectionFieldName = (Model.Name "schema")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the term field of hydra.ext.avro.testing.TermLevelForwardTestCase
termLevelForwardTestCaseTerm :: Typed.TypedTerm Testing.TermLevelForwardTestCase -> Typed.TypedTerm Model.Term
termLevelForwardTestCaseTerm x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"),
        Model.projectionFieldName = (Model.Name "term")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.avro.testing.TermLevelForwardTestCase
termLevelForwardTestCaseTermLevelForwardTestCase :: Typed.TypedName Testing.TermLevelForwardTestCase
termLevelForwardTestCaseTermLevelForwardTestCase =
    Typed.TypedName (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase")

-- | DSL updater for the description field of hydra.ext.avro.testing.TermLevelForwardTestCase
termLevelForwardTestCaseWithDescription :: Typed.TypedTerm Testing.TermLevelForwardTestCase -> Typed.TypedTerm String -> Typed.TypedTerm Testing.TermLevelForwardTestCase
termLevelForwardTestCaseWithDescription original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "json"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"),
              Model.projectionFieldName = (Model.Name "json")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "term"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"),
              Model.projectionFieldName = (Model.Name "term")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the json field of hydra.ext.avro.testing.TermLevelForwardTestCase
termLevelForwardTestCaseWithJson :: Typed.TypedTerm Testing.TermLevelForwardTestCase -> Typed.TypedTerm JsonModel.Value -> Typed.TypedTerm Testing.TermLevelForwardTestCase
termLevelForwardTestCaseWithJson original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "json"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "term"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"),
              Model.projectionFieldName = (Model.Name "term")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the schema field of hydra.ext.avro.testing.TermLevelForwardTestCase
termLevelForwardTestCaseWithSchema :: Typed.TypedTerm Testing.TermLevelForwardTestCase -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Testing.TermLevelForwardTestCase
termLevelForwardTestCaseWithSchema original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "json"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"),
              Model.projectionFieldName = (Model.Name "json")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "term"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"),
              Model.projectionFieldName = (Model.Name "term")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the term field of hydra.ext.avro.testing.TermLevelForwardTestCase
termLevelForwardTestCaseWithTerm :: Typed.TypedTerm Testing.TermLevelForwardTestCase -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Testing.TermLevelForwardTestCase
termLevelForwardTestCaseWithTerm original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "json"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelForwardTestCase"),
              Model.projectionFieldName = (Model.Name "json")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "term"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.avro.testing.TermLevelReverseTestCase
termLevelReverseTestCase :: Typed.TypedTerm String -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Model.Term -> Typed.TypedTerm JsonModel.Value -> Typed.TypedTerm Testing.TermLevelReverseTestCase
termLevelReverseTestCase description schema term json =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm description)},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Typed.unTypedTerm schema)},
        Model.Field {
          Model.fieldName = (Model.Name "term"),
          Model.fieldTerm = (Typed.unTypedTerm term)},
        Model.Field {
          Model.fieldName = (Model.Name "json"),
          Model.fieldTerm = (Typed.unTypedTerm json)}]}))

-- | DSL accessor for the description field of hydra.ext.avro.testing.TermLevelReverseTestCase
termLevelReverseTestCaseDescription :: Typed.TypedTerm Testing.TermLevelReverseTestCase -> Typed.TypedTerm String
termLevelReverseTestCaseDescription x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"),
        Model.projectionFieldName = (Model.Name "description")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the json field of hydra.ext.avro.testing.TermLevelReverseTestCase
termLevelReverseTestCaseJson :: Typed.TypedTerm Testing.TermLevelReverseTestCase -> Typed.TypedTerm JsonModel.Value
termLevelReverseTestCaseJson x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"),
        Model.projectionFieldName = (Model.Name "json")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the schema field of hydra.ext.avro.testing.TermLevelReverseTestCase
termLevelReverseTestCaseSchema :: Typed.TypedTerm Testing.TermLevelReverseTestCase -> Typed.TypedTerm Schema.Schema
termLevelReverseTestCaseSchema x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"),
        Model.projectionFieldName = (Model.Name "schema")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the term field of hydra.ext.avro.testing.TermLevelReverseTestCase
termLevelReverseTestCaseTerm :: Typed.TypedTerm Testing.TermLevelReverseTestCase -> Typed.TypedTerm Model.Term
termLevelReverseTestCaseTerm x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"),
        Model.projectionFieldName = (Model.Name "term")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.avro.testing.TermLevelReverseTestCase
termLevelReverseTestCaseTermLevelReverseTestCase :: Typed.TypedName Testing.TermLevelReverseTestCase
termLevelReverseTestCaseTermLevelReverseTestCase =
    Typed.TypedName (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase")

-- | DSL updater for the description field of hydra.ext.avro.testing.TermLevelReverseTestCase
termLevelReverseTestCaseWithDescription :: Typed.TypedTerm Testing.TermLevelReverseTestCase -> Typed.TypedTerm String -> Typed.TypedTerm Testing.TermLevelReverseTestCase
termLevelReverseTestCaseWithDescription original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "term"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"),
              Model.projectionFieldName = (Model.Name "term")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "json"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"),
              Model.projectionFieldName = (Model.Name "json")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the json field of hydra.ext.avro.testing.TermLevelReverseTestCase
termLevelReverseTestCaseWithJson :: Typed.TypedTerm Testing.TermLevelReverseTestCase -> Typed.TypedTerm JsonModel.Value -> Typed.TypedTerm Testing.TermLevelReverseTestCase
termLevelReverseTestCaseWithJson original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "term"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"),
              Model.projectionFieldName = (Model.Name "term")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "json"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the schema field of hydra.ext.avro.testing.TermLevelReverseTestCase
termLevelReverseTestCaseWithSchema :: Typed.TypedTerm Testing.TermLevelReverseTestCase -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Testing.TermLevelReverseTestCase
termLevelReverseTestCaseWithSchema original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "term"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"),
              Model.projectionFieldName = (Model.Name "term")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "json"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"),
              Model.projectionFieldName = (Model.Name "json")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the term field of hydra.ext.avro.testing.TermLevelReverseTestCase
termLevelReverseTestCaseWithTerm :: Typed.TypedTerm Testing.TermLevelReverseTestCase -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Testing.TermLevelReverseTestCase
termLevelReverseTestCaseWithTerm original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "term"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "json"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelReverseTestCase"),
              Model.projectionFieldName = (Model.Name "json")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase
termLevelRoundTripJsonTestCase :: Typed.TypedTerm String -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm JsonModel.Value -> Typed.TypedTerm JsonModel.Value -> Typed.TypedTerm Testing.TermLevelRoundTripJsonTestCase
termLevelRoundTripJsonTestCase description schema json expectedJson =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm description)},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Typed.unTypedTerm schema)},
        Model.Field {
          Model.fieldName = (Model.Name "json"),
          Model.fieldTerm = (Typed.unTypedTerm json)},
        Model.Field {
          Model.fieldName = (Model.Name "expectedJson"),
          Model.fieldTerm = (Typed.unTypedTerm expectedJson)}]}))

-- | DSL accessor for the description field of hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase
termLevelRoundTripJsonTestCaseDescription :: Typed.TypedTerm Testing.TermLevelRoundTripJsonTestCase -> Typed.TypedTerm String
termLevelRoundTripJsonTestCaseDescription x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"),
        Model.projectionFieldName = (Model.Name "description")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the expectedJson field of hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase
termLevelRoundTripJsonTestCaseExpectedJson :: Typed.TypedTerm Testing.TermLevelRoundTripJsonTestCase -> Typed.TypedTerm JsonModel.Value
termLevelRoundTripJsonTestCaseExpectedJson x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"),
        Model.projectionFieldName = (Model.Name "expectedJson")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the json field of hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase
termLevelRoundTripJsonTestCaseJson :: Typed.TypedTerm Testing.TermLevelRoundTripJsonTestCase -> Typed.TypedTerm JsonModel.Value
termLevelRoundTripJsonTestCaseJson x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"),
        Model.projectionFieldName = (Model.Name "json")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the schema field of hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase
termLevelRoundTripJsonTestCaseSchema :: Typed.TypedTerm Testing.TermLevelRoundTripJsonTestCase -> Typed.TypedTerm Schema.Schema
termLevelRoundTripJsonTestCaseSchema x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"),
        Model.projectionFieldName = (Model.Name "schema")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase
termLevelRoundTripJsonTestCaseTermLevelRoundTripJsonTestCase :: Typed.TypedName Testing.TermLevelRoundTripJsonTestCase
termLevelRoundTripJsonTestCaseTermLevelRoundTripJsonTestCase =
    Typed.TypedName (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase")

-- | DSL updater for the description field of hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase
termLevelRoundTripJsonTestCaseWithDescription :: Typed.TypedTerm Testing.TermLevelRoundTripJsonTestCase -> Typed.TypedTerm String -> Typed.TypedTerm Testing.TermLevelRoundTripJsonTestCase
termLevelRoundTripJsonTestCaseWithDescription original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "json"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"),
              Model.projectionFieldName = (Model.Name "json")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expectedJson"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"),
              Model.projectionFieldName = (Model.Name "expectedJson")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the expectedJson field of hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase
termLevelRoundTripJsonTestCaseWithExpectedJson :: Typed.TypedTerm Testing.TermLevelRoundTripJsonTestCase -> Typed.TypedTerm JsonModel.Value -> Typed.TypedTerm Testing.TermLevelRoundTripJsonTestCase
termLevelRoundTripJsonTestCaseWithExpectedJson original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "json"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"),
              Model.projectionFieldName = (Model.Name "json")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expectedJson"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the json field of hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase
termLevelRoundTripJsonTestCaseWithJson :: Typed.TypedTerm Testing.TermLevelRoundTripJsonTestCase -> Typed.TypedTerm JsonModel.Value -> Typed.TypedTerm Testing.TermLevelRoundTripJsonTestCase
termLevelRoundTripJsonTestCaseWithJson original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "json"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "expectedJson"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"),
              Model.projectionFieldName = (Model.Name "expectedJson")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the schema field of hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase
termLevelRoundTripJsonTestCaseWithSchema :: Typed.TypedTerm Testing.TermLevelRoundTripJsonTestCase -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Testing.TermLevelRoundTripJsonTestCase
termLevelRoundTripJsonTestCaseWithSchema original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "json"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"),
              Model.projectionFieldName = (Model.Name "json")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expectedJson"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripJsonTestCase"),
              Model.projectionFieldName = (Model.Name "expectedJson")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.avro.testing.TermLevelRoundTripTermTestCase
termLevelRoundTripTermTestCase :: Typed.TypedTerm String -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Testing.TermLevelRoundTripTermTestCase
termLevelRoundTripTermTestCase description type_ term expectedTerm =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm description)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "term"),
          Model.fieldTerm = (Typed.unTypedTerm term)},
        Model.Field {
          Model.fieldName = (Model.Name "expectedTerm"),
          Model.fieldTerm = (Typed.unTypedTerm expectedTerm)}]}))

-- | DSL accessor for the description field of hydra.ext.avro.testing.TermLevelRoundTripTermTestCase
termLevelRoundTripTermTestCaseDescription :: Typed.TypedTerm Testing.TermLevelRoundTripTermTestCase -> Typed.TypedTerm String
termLevelRoundTripTermTestCaseDescription x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"),
        Model.projectionFieldName = (Model.Name "description")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the expectedTerm field of hydra.ext.avro.testing.TermLevelRoundTripTermTestCase
termLevelRoundTripTermTestCaseExpectedTerm :: Typed.TypedTerm Testing.TermLevelRoundTripTermTestCase -> Typed.TypedTerm Model.Term
termLevelRoundTripTermTestCaseExpectedTerm x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"),
        Model.projectionFieldName = (Model.Name "expectedTerm")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the term field of hydra.ext.avro.testing.TermLevelRoundTripTermTestCase
termLevelRoundTripTermTestCaseTerm :: Typed.TypedTerm Testing.TermLevelRoundTripTermTestCase -> Typed.TypedTerm Model.Term
termLevelRoundTripTermTestCaseTerm x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"),
        Model.projectionFieldName = (Model.Name "term")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.avro.testing.TermLevelRoundTripTermTestCase
termLevelRoundTripTermTestCaseTermLevelRoundTripTermTestCase :: Typed.TypedName Testing.TermLevelRoundTripTermTestCase
termLevelRoundTripTermTestCaseTermLevelRoundTripTermTestCase =
    Typed.TypedName (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase")

-- | DSL accessor for the type field of hydra.ext.avro.testing.TermLevelRoundTripTermTestCase
termLevelRoundTripTermTestCaseType :: Typed.TypedTerm Testing.TermLevelRoundTripTermTestCase -> Typed.TypedTerm Model.Type
termLevelRoundTripTermTestCaseType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the description field of hydra.ext.avro.testing.TermLevelRoundTripTermTestCase
termLevelRoundTripTermTestCaseWithDescription :: Typed.TypedTerm Testing.TermLevelRoundTripTermTestCase -> Typed.TypedTerm String -> Typed.TypedTerm Testing.TermLevelRoundTripTermTestCase
termLevelRoundTripTermTestCaseWithDescription original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "term"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"),
              Model.projectionFieldName = (Model.Name "term")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expectedTerm"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"),
              Model.projectionFieldName = (Model.Name "expectedTerm")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the expectedTerm field of hydra.ext.avro.testing.TermLevelRoundTripTermTestCase
termLevelRoundTripTermTestCaseWithExpectedTerm :: Typed.TypedTerm Testing.TermLevelRoundTripTermTestCase -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Testing.TermLevelRoundTripTermTestCase
termLevelRoundTripTermTestCaseWithExpectedTerm original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "term"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"),
              Model.projectionFieldName = (Model.Name "term")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expectedTerm"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the term field of hydra.ext.avro.testing.TermLevelRoundTripTermTestCase
termLevelRoundTripTermTestCaseWithTerm :: Typed.TypedTerm Testing.TermLevelRoundTripTermTestCase -> Typed.TypedTerm Model.Term -> Typed.TypedTerm Testing.TermLevelRoundTripTermTestCase
termLevelRoundTripTermTestCaseWithTerm original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "term"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "expectedTerm"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"),
              Model.projectionFieldName = (Model.Name "expectedTerm")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.avro.testing.TermLevelRoundTripTermTestCase
termLevelRoundTripTermTestCaseWithType :: Typed.TypedTerm Testing.TermLevelRoundTripTermTestCase -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Testing.TermLevelRoundTripTermTestCase
termLevelRoundTripTermTestCaseWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "term"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"),
              Model.projectionFieldName = (Model.Name "term")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expectedTerm"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TermLevelRoundTripTermTestCase"),
              Model.projectionFieldName = (Model.Name "expectedTerm")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.avro.testing.TypeLevelForwardTestCase
typeLevelForwardTestCase :: Typed.TypedTerm String -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Testing.TypeLevelForwardTestCase
typeLevelForwardTestCase description schema type_ =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelForwardTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm description)},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Typed.unTypedTerm schema)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)}]}))

-- | DSL accessor for the description field of hydra.ext.avro.testing.TypeLevelForwardTestCase
typeLevelForwardTestCaseDescription :: Typed.TypedTerm Testing.TypeLevelForwardTestCase -> Typed.TypedTerm String
typeLevelForwardTestCaseDescription x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelForwardTestCase"),
        Model.projectionFieldName = (Model.Name "description")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the schema field of hydra.ext.avro.testing.TypeLevelForwardTestCase
typeLevelForwardTestCaseSchema :: Typed.TypedTerm Testing.TypeLevelForwardTestCase -> Typed.TypedTerm Schema.Schema
typeLevelForwardTestCaseSchema x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelForwardTestCase"),
        Model.projectionFieldName = (Model.Name "schema")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.avro.testing.TypeLevelForwardTestCase
typeLevelForwardTestCaseType :: Typed.TypedTerm Testing.TypeLevelForwardTestCase -> Typed.TypedTerm Model.Type
typeLevelForwardTestCaseType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelForwardTestCase"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.avro.testing.TypeLevelForwardTestCase
typeLevelForwardTestCaseTypeLevelForwardTestCase :: Typed.TypedName Testing.TypeLevelForwardTestCase
typeLevelForwardTestCaseTypeLevelForwardTestCase =
    Typed.TypedName (Model.Name "hydra.ext.avro.testing.TypeLevelForwardTestCase")

-- | DSL updater for the description field of hydra.ext.avro.testing.TypeLevelForwardTestCase
typeLevelForwardTestCaseWithDescription :: Typed.TypedTerm Testing.TypeLevelForwardTestCase -> Typed.TypedTerm String -> Typed.TypedTerm Testing.TypeLevelForwardTestCase
typeLevelForwardTestCaseWithDescription original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelForwardTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelForwardTestCase"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelForwardTestCase"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the schema field of hydra.ext.avro.testing.TypeLevelForwardTestCase
typeLevelForwardTestCaseWithSchema :: Typed.TypedTerm Testing.TypeLevelForwardTestCase -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Testing.TypeLevelForwardTestCase
typeLevelForwardTestCaseWithSchema original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelForwardTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelForwardTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelForwardTestCase"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.avro.testing.TypeLevelForwardTestCase
typeLevelForwardTestCaseWithType :: Typed.TypedTerm Testing.TypeLevelForwardTestCase -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Testing.TypeLevelForwardTestCase
typeLevelForwardTestCaseWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelForwardTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelForwardTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelForwardTestCase"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.avro.testing.TypeLevelReverseTestCase
typeLevelReverseTestCase :: Typed.TypedTerm String -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Testing.TypeLevelReverseTestCase
typeLevelReverseTestCase description type_ schema =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelReverseTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm description)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Typed.unTypedTerm schema)}]}))

-- | DSL accessor for the description field of hydra.ext.avro.testing.TypeLevelReverseTestCase
typeLevelReverseTestCaseDescription :: Typed.TypedTerm Testing.TypeLevelReverseTestCase -> Typed.TypedTerm String
typeLevelReverseTestCaseDescription x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelReverseTestCase"),
        Model.projectionFieldName = (Model.Name "description")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the schema field of hydra.ext.avro.testing.TypeLevelReverseTestCase
typeLevelReverseTestCaseSchema :: Typed.TypedTerm Testing.TypeLevelReverseTestCase -> Typed.TypedTerm Schema.Schema
typeLevelReverseTestCaseSchema x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelReverseTestCase"),
        Model.projectionFieldName = (Model.Name "schema")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.avro.testing.TypeLevelReverseTestCase
typeLevelReverseTestCaseType :: Typed.TypedTerm Testing.TypeLevelReverseTestCase -> Typed.TypedTerm Model.Type
typeLevelReverseTestCaseType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelReverseTestCase"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.avro.testing.TypeLevelReverseTestCase
typeLevelReverseTestCaseTypeLevelReverseTestCase :: Typed.TypedName Testing.TypeLevelReverseTestCase
typeLevelReverseTestCaseTypeLevelReverseTestCase =
    Typed.TypedName (Model.Name "hydra.ext.avro.testing.TypeLevelReverseTestCase")

-- | DSL updater for the description field of hydra.ext.avro.testing.TypeLevelReverseTestCase
typeLevelReverseTestCaseWithDescription :: Typed.TypedTerm Testing.TypeLevelReverseTestCase -> Typed.TypedTerm String -> Typed.TypedTerm Testing.TypeLevelReverseTestCase
typeLevelReverseTestCaseWithDescription original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelReverseTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelReverseTestCase"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelReverseTestCase"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the schema field of hydra.ext.avro.testing.TypeLevelReverseTestCase
typeLevelReverseTestCaseWithSchema :: Typed.TypedTerm Testing.TypeLevelReverseTestCase -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Testing.TypeLevelReverseTestCase
typeLevelReverseTestCaseWithSchema original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelReverseTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelReverseTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelReverseTestCase"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the type field of hydra.ext.avro.testing.TypeLevelReverseTestCase
typeLevelReverseTestCaseWithType :: Typed.TypedTerm Testing.TypeLevelReverseTestCase -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Testing.TypeLevelReverseTestCase
typeLevelReverseTestCaseWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelReverseTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelReverseTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelReverseTestCase"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase
typeLevelRoundTripAvroTestCase :: Typed.TypedTerm String -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Testing.TypeLevelRoundTripAvroTestCase
typeLevelRoundTripAvroTestCase description schema expectedSchema =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm description)},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Typed.unTypedTerm schema)},
        Model.Field {
          Model.fieldName = (Model.Name "expectedSchema"),
          Model.fieldTerm = (Typed.unTypedTerm expectedSchema)}]}))

-- | DSL accessor for the description field of hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase
typeLevelRoundTripAvroTestCaseDescription :: Typed.TypedTerm Testing.TypeLevelRoundTripAvroTestCase -> Typed.TypedTerm String
typeLevelRoundTripAvroTestCaseDescription x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase"),
        Model.projectionFieldName = (Model.Name "description")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the expectedSchema field of hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase
typeLevelRoundTripAvroTestCaseExpectedSchema :: Typed.TypedTerm Testing.TypeLevelRoundTripAvroTestCase -> Typed.TypedTerm Schema.Schema
typeLevelRoundTripAvroTestCaseExpectedSchema x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase"),
        Model.projectionFieldName = (Model.Name "expectedSchema")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the schema field of hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase
typeLevelRoundTripAvroTestCaseSchema :: Typed.TypedTerm Testing.TypeLevelRoundTripAvroTestCase -> Typed.TypedTerm Schema.Schema
typeLevelRoundTripAvroTestCaseSchema x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase"),
        Model.projectionFieldName = (Model.Name "schema")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase
typeLevelRoundTripAvroTestCaseTypeLevelRoundTripAvroTestCase :: Typed.TypedName Testing.TypeLevelRoundTripAvroTestCase
typeLevelRoundTripAvroTestCaseTypeLevelRoundTripAvroTestCase =
    Typed.TypedName (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase")

-- | DSL updater for the description field of hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase
typeLevelRoundTripAvroTestCaseWithDescription :: Typed.TypedTerm Testing.TypeLevelRoundTripAvroTestCase -> Typed.TypedTerm String -> Typed.TypedTerm Testing.TypeLevelRoundTripAvroTestCase
typeLevelRoundTripAvroTestCaseWithDescription original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expectedSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase"),
              Model.projectionFieldName = (Model.Name "expectedSchema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the expectedSchema field of hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase
typeLevelRoundTripAvroTestCaseWithExpectedSchema :: Typed.TypedTerm Testing.TypeLevelRoundTripAvroTestCase -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Testing.TypeLevelRoundTripAvroTestCase
typeLevelRoundTripAvroTestCaseWithExpectedSchema original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expectedSchema"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the schema field of hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase
typeLevelRoundTripAvroTestCaseWithSchema :: Typed.TypedTerm Testing.TypeLevelRoundTripAvroTestCase -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Testing.TypeLevelRoundTripAvroTestCase
typeLevelRoundTripAvroTestCaseWithSchema original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "expectedSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripAvroTestCase"),
              Model.projectionFieldName = (Model.Name "expectedSchema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase
typeLevelRoundTripHydraTestCase :: Typed.TypedTerm String -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Testing.TypeLevelRoundTripHydraTestCase
typeLevelRoundTripHydraTestCase description type_ expectedType =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm description)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "expectedType"),
          Model.fieldTerm = (Typed.unTypedTerm expectedType)}]}))

-- | DSL accessor for the description field of hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase
typeLevelRoundTripHydraTestCaseDescription :: Typed.TypedTerm Testing.TypeLevelRoundTripHydraTestCase -> Typed.TypedTerm String
typeLevelRoundTripHydraTestCaseDescription x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase"),
        Model.projectionFieldName = (Model.Name "description")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the expectedType field of hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase
typeLevelRoundTripHydraTestCaseExpectedType :: Typed.TypedTerm Testing.TypeLevelRoundTripHydraTestCase -> Typed.TypedTerm Model.Type
typeLevelRoundTripHydraTestCaseExpectedType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase"),
        Model.projectionFieldName = (Model.Name "expectedType")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase
typeLevelRoundTripHydraTestCaseType :: Typed.TypedTerm Testing.TypeLevelRoundTripHydraTestCase -> Typed.TypedTerm Model.Type
typeLevelRoundTripHydraTestCaseType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase
typeLevelRoundTripHydraTestCaseTypeLevelRoundTripHydraTestCase :: Typed.TypedName Testing.TypeLevelRoundTripHydraTestCase
typeLevelRoundTripHydraTestCaseTypeLevelRoundTripHydraTestCase =
    Typed.TypedName (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase")

-- | DSL updater for the description field of hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase
typeLevelRoundTripHydraTestCaseWithDescription :: Typed.TypedTerm Testing.TypeLevelRoundTripHydraTestCase -> Typed.TypedTerm String -> Typed.TypedTerm Testing.TypeLevelRoundTripHydraTestCase
typeLevelRoundTripHydraTestCaseWithDescription original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expectedType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase"),
              Model.projectionFieldName = (Model.Name "expectedType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the expectedType field of hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase
typeLevelRoundTripHydraTestCaseWithExpectedType :: Typed.TypedTerm Testing.TypeLevelRoundTripHydraTestCase -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Testing.TypeLevelRoundTripHydraTestCase
typeLevelRoundTripHydraTestCaseWithExpectedType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "expectedType"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the type field of hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase
typeLevelRoundTripHydraTestCaseWithType :: Typed.TypedTerm Testing.TypeLevelRoundTripHydraTestCase -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Testing.TypeLevelRoundTripHydraTestCase
typeLevelRoundTripHydraTestCaseWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "expectedType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.TypeLevelRoundTripHydraTestCase"),
              Model.projectionFieldName = (Model.Name "expectedType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.avro.testing.UnionTestCase
unionTestCase :: Typed.TypedTerm String -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm [(Model.Term, JsonModel.Value)] -> Typed.TypedTerm Testing.UnionTestCase
unionTestCase description hydraType avroSchema termPairs =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm description)},
        Model.Field {
          Model.fieldName = (Model.Name "hydraType"),
          Model.fieldTerm = (Typed.unTypedTerm hydraType)},
        Model.Field {
          Model.fieldName = (Model.Name "avroSchema"),
          Model.fieldTerm = (Typed.unTypedTerm avroSchema)},
        Model.Field {
          Model.fieldName = (Model.Name "termPairs"),
          Model.fieldTerm = (Typed.unTypedTerm termPairs)}]}))

-- | DSL accessor for the avroSchema field of hydra.ext.avro.testing.UnionTestCase
unionTestCaseAvroSchema :: Typed.TypedTerm Testing.UnionTestCase -> Typed.TypedTerm Schema.Schema
unionTestCaseAvroSchema x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"),
        Model.projectionFieldName = (Model.Name "avroSchema")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the description field of hydra.ext.avro.testing.UnionTestCase
unionTestCaseDescription :: Typed.TypedTerm Testing.UnionTestCase -> Typed.TypedTerm String
unionTestCaseDescription x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"),
        Model.projectionFieldName = (Model.Name "description")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the hydraType field of hydra.ext.avro.testing.UnionTestCase
unionTestCaseHydraType :: Typed.TypedTerm Testing.UnionTestCase -> Typed.TypedTerm Model.Type
unionTestCaseHydraType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"),
        Model.projectionFieldName = (Model.Name "hydraType")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the termPairs field of hydra.ext.avro.testing.UnionTestCase
unionTestCaseTermPairs :: Typed.TypedTerm Testing.UnionTestCase -> Typed.TypedTerm [(Model.Term, JsonModel.Value)]
unionTestCaseTermPairs x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"),
        Model.projectionFieldName = (Model.Name "termPairs")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.avro.testing.UnionTestCase
unionTestCaseUnionTestCase :: Typed.TypedName Testing.UnionTestCase
unionTestCaseUnionTestCase = Typed.TypedName (Model.Name "hydra.ext.avro.testing.UnionTestCase")

-- | DSL updater for the avroSchema field of hydra.ext.avro.testing.UnionTestCase
unionTestCaseWithAvroSchema :: Typed.TypedTerm Testing.UnionTestCase -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Testing.UnionTestCase
unionTestCaseWithAvroSchema original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "hydraType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"),
              Model.projectionFieldName = (Model.Name "hydraType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "avroSchema"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "termPairs"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"),
              Model.projectionFieldName = (Model.Name "termPairs")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the description field of hydra.ext.avro.testing.UnionTestCase
unionTestCaseWithDescription :: Typed.TypedTerm Testing.UnionTestCase -> Typed.TypedTerm String -> Typed.TypedTerm Testing.UnionTestCase
unionTestCaseWithDescription original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "hydraType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"),
              Model.projectionFieldName = (Model.Name "hydraType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "avroSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"),
              Model.projectionFieldName = (Model.Name "avroSchema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "termPairs"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"),
              Model.projectionFieldName = (Model.Name "termPairs")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the hydraType field of hydra.ext.avro.testing.UnionTestCase
unionTestCaseWithHydraType :: Typed.TypedTerm Testing.UnionTestCase -> Typed.TypedTerm Model.Type -> Typed.TypedTerm Testing.UnionTestCase
unionTestCaseWithHydraType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "hydraType"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "avroSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"),
              Model.projectionFieldName = (Model.Name "avroSchema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "termPairs"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"),
              Model.projectionFieldName = (Model.Name "termPairs")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the termPairs field of hydra.ext.avro.testing.UnionTestCase
unionTestCaseWithTermPairs :: Typed.TypedTerm Testing.UnionTestCase -> Typed.TypedTerm [(Model.Term, JsonModel.Value)] -> Typed.TypedTerm Testing.UnionTestCase
unionTestCaseWithTermPairs original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "hydraType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"),
              Model.projectionFieldName = (Model.Name "hydraType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "avroSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.testing.UnionTestCase"),
              Model.projectionFieldName = (Model.Name "avroSchema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "termPairs"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))