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

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

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

module Hydra.Ext.Dsl.Avro.Schema 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 Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
import qualified Data.Scientific as Sci
import Data.Void
import qualified Data.Map as M

-- | DSL constructor for hydra.ext.avro.schema.Array
array :: Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Schema.Array
array items =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Array"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "items"),
          Model.fieldTerm = (Typed.unTypedTerm items)}]}))

-- | DSL name token for hydra.ext.avro.schema.Array
arrayArray :: Typed.TypedName Schema.Array
arrayArray = Typed.TypedName (Model.Name "hydra.ext.avro.schema.Array")

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

-- | DSL updater for the items field of hydra.ext.avro.schema.Array
arrayWithItems :: Typed.TypedTerm Schema.Array -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Schema.Array
arrayWithItems original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Array"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "items"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.avro.schema.Enum
enum :: Typed.TypedTerm [String] -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Schema.Enum
enum symbols default_ =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Enum"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "symbols"),
          Model.fieldTerm = (Typed.unTypedTerm symbols)},
        Model.Field {
          Model.fieldName = (Model.Name "default"),
          Model.fieldTerm = (Typed.unTypedTerm default_)}]}))

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

-- | DSL name token for hydra.ext.avro.schema.Enum
enumEnum :: Typed.TypedName Schema.Enum
enumEnum = Typed.TypedName (Model.Name "hydra.ext.avro.schema.Enum")

-- | DSL accessor for the symbols field of hydra.ext.avro.schema.Enum
enumSymbols :: Typed.TypedTerm Schema.Enum -> Typed.TypedTerm [String]
enumSymbols x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Enum"),
        Model.projectionFieldName = (Model.Name "symbols")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the default field of hydra.ext.avro.schema.Enum
enumWithDefault :: Typed.TypedTerm Schema.Enum -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Schema.Enum
enumWithDefault original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Enum"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "symbols"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Enum"),
              Model.projectionFieldName = (Model.Name "symbols")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "default"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

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

-- | DSL constructor for hydra.ext.avro.schema.Field
field :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm (Maybe JsonModel.Value) -> Typed.TypedTerm (Maybe Schema.Order) -> Typed.TypedTerm (Maybe [String]) -> Typed.TypedTerm (M.Map String JsonModel.Value) -> Typed.TypedTerm Schema.Field
field name doc type_ default_ order aliases annotations =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "doc"),
          Model.fieldTerm = (Typed.unTypedTerm doc)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "default"),
          Model.fieldTerm = (Typed.unTypedTerm default_)},
        Model.Field {
          Model.fieldName = (Model.Name "order"),
          Model.fieldTerm = (Typed.unTypedTerm order)},
        Model.Field {
          Model.fieldName = (Model.Name "aliases"),
          Model.fieldTerm = (Typed.unTypedTerm aliases)},
        Model.Field {
          Model.fieldName = (Model.Name "annotations"),
          Model.fieldTerm = (Typed.unTypedTerm annotations)}]}))

-- | DSL accessor for the aliases field of hydra.ext.avro.schema.Field
fieldAliases :: Typed.TypedTerm Schema.Field -> Typed.TypedTerm (Maybe [String])
fieldAliases x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
        Model.projectionFieldName = (Model.Name "aliases")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the annotations field of hydra.ext.avro.schema.Field
fieldAnnotations :: Typed.TypedTerm Schema.Field -> Typed.TypedTerm (M.Map String JsonModel.Value)
fieldAnnotations x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
        Model.projectionFieldName = (Model.Name "annotations")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the default field of hydra.ext.avro.schema.Field
fieldDefault :: Typed.TypedTerm Schema.Field -> Typed.TypedTerm (Maybe JsonModel.Value)
fieldDefault x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
        Model.projectionFieldName = (Model.Name "default")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

-- | DSL name token for hydra.ext.avro.schema.Field
fieldField :: Typed.TypedName Schema.Field
fieldField = Typed.TypedName (Model.Name "hydra.ext.avro.schema.Field")

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

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

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

-- | DSL updater for the aliases field of hydra.ext.avro.schema.Field
fieldWithAliases :: Typed.TypedTerm Schema.Field -> Typed.TypedTerm (Maybe [String]) -> Typed.TypedTerm Schema.Field
fieldWithAliases original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "doc"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
              Model.projectionFieldName = (Model.Name "doc")})),
            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.schema.Field"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "default"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
              Model.projectionFieldName = (Model.Name "default")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "order"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
              Model.projectionFieldName = (Model.Name "order")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "aliases"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "annotations"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
              Model.projectionFieldName = (Model.Name "annotations")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the annotations field of hydra.ext.avro.schema.Field
fieldWithAnnotations :: Typed.TypedTerm Schema.Field -> Typed.TypedTerm (M.Map String JsonModel.Value) -> Typed.TypedTerm Schema.Field
fieldWithAnnotations original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "doc"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
              Model.projectionFieldName = (Model.Name "doc")})),
            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.schema.Field"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "default"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
              Model.projectionFieldName = (Model.Name "default")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "order"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
              Model.projectionFieldName = (Model.Name "order")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "aliases"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
              Model.projectionFieldName = (Model.Name "aliases")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "annotations"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the default field of hydra.ext.avro.schema.Field
fieldWithDefault :: Typed.TypedTerm Schema.Field -> Typed.TypedTerm (Maybe JsonModel.Value) -> Typed.TypedTerm Schema.Field
fieldWithDefault original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "doc"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
              Model.projectionFieldName = (Model.Name "doc")})),
            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.schema.Field"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "default"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "order"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
              Model.projectionFieldName = (Model.Name "order")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "aliases"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
              Model.projectionFieldName = (Model.Name "aliases")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "annotations"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
              Model.projectionFieldName = (Model.Name "annotations")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the doc field of hydra.ext.avro.schema.Field
fieldWithDoc :: Typed.TypedTerm Schema.Field -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Schema.Field
fieldWithDoc original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "doc"),
          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.schema.Field"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "default"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
              Model.projectionFieldName = (Model.Name "default")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "order"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
              Model.projectionFieldName = (Model.Name "order")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "aliases"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
              Model.projectionFieldName = (Model.Name "aliases")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "annotations"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
              Model.projectionFieldName = (Model.Name "annotations")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.avro.schema.Field
fieldWithName :: Typed.TypedTerm Schema.Field -> Typed.TypedTerm String -> Typed.TypedTerm Schema.Field
fieldWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "doc"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
              Model.projectionFieldName = (Model.Name "doc")})),
            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.schema.Field"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "default"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
              Model.projectionFieldName = (Model.Name "default")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "order"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
              Model.projectionFieldName = (Model.Name "order")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "aliases"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
              Model.projectionFieldName = (Model.Name "aliases")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "annotations"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
              Model.projectionFieldName = (Model.Name "annotations")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the order field of hydra.ext.avro.schema.Field
fieldWithOrder :: Typed.TypedTerm Schema.Field -> Typed.TypedTerm (Maybe Schema.Order) -> Typed.TypedTerm Schema.Field
fieldWithOrder original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "doc"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
              Model.projectionFieldName = (Model.Name "doc")})),
            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.schema.Field"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "default"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
              Model.projectionFieldName = (Model.Name "default")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "order"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "aliases"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
              Model.projectionFieldName = (Model.Name "aliases")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "annotations"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Field"),
              Model.projectionFieldName = (Model.Name "annotations")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

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

-- | DSL constructor for hydra.ext.avro.schema.Fixed
fixed :: Typed.TypedTerm Int -> Typed.TypedTerm Schema.Fixed
fixed size =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Fixed"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "size"),
          Model.fieldTerm = (Typed.unTypedTerm size)}]}))

-- | DSL name token for hydra.ext.avro.schema.Fixed
fixedFixed :: Typed.TypedName Schema.Fixed
fixedFixed = Typed.TypedName (Model.Name "hydra.ext.avro.schema.Fixed")

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

-- | DSL updater for the size field of hydra.ext.avro.schema.Fixed
fixedWithSize :: Typed.TypedTerm Schema.Fixed -> Typed.TypedTerm Int -> Typed.TypedTerm Schema.Fixed
fixedWithSize original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Fixed"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "size"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.avro.schema.Map
map :: Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Schema.Map
map values =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Map"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "values"),
          Model.fieldTerm = (Typed.unTypedTerm values)}]}))

-- | DSL name token for hydra.ext.avro.schema.Map
mapMap :: Typed.TypedName Schema.Map
mapMap = Typed.TypedName (Model.Name "hydra.ext.avro.schema.Map")

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

-- | DSL updater for the values field of hydra.ext.avro.schema.Map
mapWithValues :: Typed.TypedTerm Schema.Map -> Typed.TypedTerm Schema.Schema -> Typed.TypedTerm Schema.Map
mapWithValues original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Map"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "values"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.avro.schema.Named
named :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe [String]) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Schema.NamedType -> Typed.TypedTerm (M.Map String JsonModel.Value) -> Typed.TypedTerm Schema.Named
named name namespace aliases doc type_ annotations =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "namespace"),
          Model.fieldTerm = (Typed.unTypedTerm namespace)},
        Model.Field {
          Model.fieldName = (Model.Name "aliases"),
          Model.fieldTerm = (Typed.unTypedTerm aliases)},
        Model.Field {
          Model.fieldName = (Model.Name "doc"),
          Model.fieldTerm = (Typed.unTypedTerm doc)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "annotations"),
          Model.fieldTerm = (Typed.unTypedTerm annotations)}]}))

-- | DSL accessor for the aliases field of hydra.ext.avro.schema.Named
namedAliases :: Typed.TypedTerm Schema.Named -> Typed.TypedTerm (Maybe [String])
namedAliases x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
        Model.projectionFieldName = (Model.Name "aliases")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the annotations field of hydra.ext.avro.schema.Named
namedAnnotations :: Typed.TypedTerm Schema.Named -> Typed.TypedTerm (M.Map String JsonModel.Value)
namedAnnotations x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
        Model.projectionFieldName = (Model.Name "annotations")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

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

-- | DSL name token for hydra.ext.avro.schema.Named
namedNamed :: Typed.TypedName Schema.Named
namedNamed = Typed.TypedName (Model.Name "hydra.ext.avro.schema.Named")

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

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

-- | DSL injection for the enum variant of hydra.ext.avro.schema.NamedType
namedTypeEnum :: Typed.TypedTerm Schema.Enum -> Typed.TypedTerm Schema.NamedType
namedTypeEnum x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.NamedType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "enum"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the fixed variant of hydra.ext.avro.schema.NamedType
namedTypeFixed :: Typed.TypedTerm Schema.Fixed -> Typed.TypedTerm Schema.NamedType
namedTypeFixed x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.NamedType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "fixed"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.avro.schema.NamedType
namedTypeNamedType :: Typed.TypedName Schema.NamedType
namedTypeNamedType = Typed.TypedName (Model.Name "hydra.ext.avro.schema.NamedType")

-- | DSL injection for the record variant of hydra.ext.avro.schema.NamedType
namedTypeRecord :: Typed.TypedTerm Schema.Record -> Typed.TypedTerm Schema.NamedType
namedTypeRecord x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.NamedType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "record"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL updater for the aliases field of hydra.ext.avro.schema.Named
namedWithAliases :: Typed.TypedTerm Schema.Named -> Typed.TypedTerm (Maybe [String]) -> Typed.TypedTerm Schema.Named
namedWithAliases original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "namespace"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
              Model.projectionFieldName = (Model.Name "namespace")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "aliases"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "doc"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
              Model.projectionFieldName = (Model.Name "doc")})),
            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.schema.Named"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "annotations"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
              Model.projectionFieldName = (Model.Name "annotations")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the annotations field of hydra.ext.avro.schema.Named
namedWithAnnotations :: Typed.TypedTerm Schema.Named -> Typed.TypedTerm (M.Map String JsonModel.Value) -> Typed.TypedTerm Schema.Named
namedWithAnnotations original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "namespace"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
              Model.projectionFieldName = (Model.Name "namespace")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "aliases"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
              Model.projectionFieldName = (Model.Name "aliases")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "doc"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
              Model.projectionFieldName = (Model.Name "doc")})),
            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.schema.Named"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "annotations"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the doc field of hydra.ext.avro.schema.Named
namedWithDoc :: Typed.TypedTerm Schema.Named -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Schema.Named
namedWithDoc original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "namespace"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
              Model.projectionFieldName = (Model.Name "namespace")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "aliases"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
              Model.projectionFieldName = (Model.Name "aliases")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "doc"),
          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.schema.Named"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "annotations"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
              Model.projectionFieldName = (Model.Name "annotations")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.avro.schema.Named
namedWithName :: Typed.TypedTerm Schema.Named -> Typed.TypedTerm String -> Typed.TypedTerm Schema.Named
namedWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "namespace"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
              Model.projectionFieldName = (Model.Name "namespace")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "aliases"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
              Model.projectionFieldName = (Model.Name "aliases")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "doc"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
              Model.projectionFieldName = (Model.Name "doc")})),
            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.schema.Named"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "annotations"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
              Model.projectionFieldName = (Model.Name "annotations")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the namespace field of hydra.ext.avro.schema.Named
namedWithNamespace :: Typed.TypedTerm Schema.Named -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Schema.Named
namedWithNamespace original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "namespace"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "aliases"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
              Model.projectionFieldName = (Model.Name "aliases")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "doc"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
              Model.projectionFieldName = (Model.Name "doc")})),
            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.schema.Named"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "annotations"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
              Model.projectionFieldName = (Model.Name "annotations")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.avro.schema.Named
namedWithType :: Typed.TypedTerm Schema.Named -> Typed.TypedTerm Schema.NamedType -> Typed.TypedTerm Schema.Named
namedWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "namespace"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
              Model.projectionFieldName = (Model.Name "namespace")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "aliases"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
              Model.projectionFieldName = (Model.Name "aliases")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "doc"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
              Model.projectionFieldName = (Model.Name "doc")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "annotations"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Named"),
              Model.projectionFieldName = (Model.Name "annotations")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the ascending variant of hydra.ext.avro.schema.Order
orderAscending :: Typed.TypedTerm Schema.Order
orderAscending =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Order"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "ascending"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the descending variant of hydra.ext.avro.schema.Order
orderDescending :: Typed.TypedTerm Schema.Order
orderDescending =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Order"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "descending"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the ignore variant of hydra.ext.avro.schema.Order
orderIgnore :: Typed.TypedTerm Schema.Order
orderIgnore =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Order"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "ignore"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.avro.schema.Order
orderOrder :: Typed.TypedName Schema.Order
orderOrder = Typed.TypedName (Model.Name "hydra.ext.avro.schema.Order")

-- | DSL injection for the boolean variant of hydra.ext.avro.schema.Primitive
primitiveBoolean :: Typed.TypedTerm Schema.Primitive
primitiveBoolean =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Primitive"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "boolean"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the bytes variant of hydra.ext.avro.schema.Primitive
primitiveBytes :: Typed.TypedTerm Schema.Primitive
primitiveBytes =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Primitive"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "bytes"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the double variant of hydra.ext.avro.schema.Primitive
primitiveDouble :: Typed.TypedTerm Schema.Primitive
primitiveDouble =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Primitive"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "double"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the float variant of hydra.ext.avro.schema.Primitive
primitiveFloat :: Typed.TypedTerm Schema.Primitive
primitiveFloat =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Primitive"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "float"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the int variant of hydra.ext.avro.schema.Primitive
primitiveInt :: Typed.TypedTerm Schema.Primitive
primitiveInt =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Primitive"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "int"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the long variant of hydra.ext.avro.schema.Primitive
primitiveLong :: Typed.TypedTerm Schema.Primitive
primitiveLong =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Primitive"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "long"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the null variant of hydra.ext.avro.schema.Primitive
primitiveNull :: Typed.TypedTerm Schema.Primitive
primitiveNull =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Primitive"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "null"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.avro.schema.Primitive
primitivePrimitive :: Typed.TypedName Schema.Primitive
primitivePrimitive = Typed.TypedName (Model.Name "hydra.ext.avro.schema.Primitive")

-- | DSL injection for the string variant of hydra.ext.avro.schema.Primitive
primitiveString :: Typed.TypedTerm Schema.Primitive
primitiveString =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Primitive"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "string"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL constructor for hydra.ext.avro.schema.Record
record :: Typed.TypedTerm [Schema.Field] -> Typed.TypedTerm Schema.Record
record fields =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Record"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "fields"),
          Model.fieldTerm = (Typed.unTypedTerm fields)}]}))

-- | DSL accessor for the fields field of hydra.ext.avro.schema.Record
recordFields :: Typed.TypedTerm Schema.Record -> Typed.TypedTerm [Schema.Field]
recordFields x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.avro.schema.Record"),
        Model.projectionFieldName = (Model.Name "fields")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.avro.schema.Record
recordRecord :: Typed.TypedName Schema.Record
recordRecord = Typed.TypedName (Model.Name "hydra.ext.avro.schema.Record")

-- | DSL updater for the fields field of hydra.ext.avro.schema.Record
recordWithFields :: Typed.TypedTerm Schema.Record -> Typed.TypedTerm [Schema.Field] -> Typed.TypedTerm Schema.Record
recordWithFields original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.avro.schema.Record"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "fields"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the array variant of hydra.ext.avro.schema.Schema
schemaArray :: Typed.TypedTerm Schema.Array -> Typed.TypedTerm Schema.Schema
schemaArray x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Schema"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "array"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the map variant of hydra.ext.avro.schema.Schema
schemaMap :: Typed.TypedTerm Schema.Map -> Typed.TypedTerm Schema.Schema
schemaMap x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Schema"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "map"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the named variant of hydra.ext.avro.schema.Schema
schemaNamed :: Typed.TypedTerm Schema.Named -> Typed.TypedTerm Schema.Schema
schemaNamed x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Schema"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "named"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the primitive variant of hydra.ext.avro.schema.Schema
schemaPrimitive :: Typed.TypedTerm Schema.Primitive -> Typed.TypedTerm Schema.Schema
schemaPrimitive x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Schema"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "primitive"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the reference variant of hydra.ext.avro.schema.Schema
schemaReference :: Typed.TypedTerm String -> Typed.TypedTerm Schema.Schema
schemaReference x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Schema"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "reference"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.avro.schema.Schema
schemaSchema :: Typed.TypedName Schema.Schema
schemaSchema = Typed.TypedName (Model.Name "hydra.ext.avro.schema.Schema")

-- | DSL injection for the union variant of hydra.ext.avro.schema.Schema
schemaUnion :: Typed.TypedTerm Schema.Union -> Typed.TypedTerm Schema.Schema
schemaUnion x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.avro.schema.Schema"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "union"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL accessor for the body of hydra.ext.avro.schema.Union
unUnion :: Typed.TypedTerm Schema.Union -> Typed.TypedTerm [Schema.Schema]
unUnion x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.avro.schema.Union")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL constructor for the hydra.ext.avro.schema.Union wrapper
union :: Typed.TypedTerm [Schema.Schema] -> Typed.TypedTerm Schema.Union
union x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.avro.schema.Union"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.avro.schema.Union
unionUnion :: Typed.TypedName Schema.Union
unionUnion = Typed.TypedName (Model.Name "hydra.ext.avro.schema.Union")