hydra-ext-0.18.0: src/main/haskell/Hydra/Ext/Dsl/Protobuf/Proto3.hs

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

-- | DSL functions for hydra.ext.protobuf.proto3

module Hydra.Ext.Dsl.Protobuf.Proto3 where

import qualified Hydra.Core.Model as Model
import qualified Hydra.Core.Typed as Typed
import qualified Hydra.Ext.Protobuf.Proto3 as Proto3
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.protobuf.proto3.Definition
definitionDefinition :: Typed.TypedName Proto3.Definition
definitionDefinition = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.Definition")

-- | DSL injection for the enum variant of hydra.ext.protobuf.proto3.Definition
definitionEnum :: Typed.TypedTerm Proto3.EnumDefinition -> Typed.TypedTerm Proto3.Definition
definitionEnum x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Definition"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "enum"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the message variant of hydra.ext.protobuf.proto3.Definition
definitionMessage :: Typed.TypedTerm Proto3.MessageDefinition -> Typed.TypedTerm Proto3.Definition
definitionMessage x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Definition"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "message"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.protobuf.proto3.EnumDefinition
enumDefinition :: Typed.TypedTerm Proto3.TypeName -> Typed.TypedTerm [Proto3.EnumValue] -> Typed.TypedTerm [Proto3.Option] -> Typed.TypedTerm Proto3.EnumDefinition
enumDefinition name values options =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumDefinition"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "values"),
          Model.fieldTerm = (Typed.unTypedTerm values)},
        Model.Field {
          Model.fieldName = (Model.Name "options"),
          Model.fieldTerm = (Typed.unTypedTerm options)}]}))

-- | DSL name token for hydra.ext.protobuf.proto3.EnumDefinition
enumDefinitionEnumDefinition :: Typed.TypedName Proto3.EnumDefinition
enumDefinitionEnumDefinition = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.EnumDefinition")

-- | DSL accessor for the name field of hydra.ext.protobuf.proto3.EnumDefinition
enumDefinitionName :: Typed.TypedTerm Proto3.EnumDefinition -> Typed.TypedTerm Proto3.TypeName
enumDefinitionName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumDefinition"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the options field of hydra.ext.protobuf.proto3.EnumDefinition
enumDefinitionOptions :: Typed.TypedTerm Proto3.EnumDefinition -> Typed.TypedTerm [Proto3.Option]
enumDefinitionOptions x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumDefinition"),
        Model.projectionFieldName = (Model.Name "options")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the values field of hydra.ext.protobuf.proto3.EnumDefinition
enumDefinitionValues :: Typed.TypedTerm Proto3.EnumDefinition -> Typed.TypedTerm [Proto3.EnumValue]
enumDefinitionValues x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumDefinition"),
        Model.projectionFieldName = (Model.Name "values")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the name field of hydra.ext.protobuf.proto3.EnumDefinition
enumDefinitionWithName :: Typed.TypedTerm Proto3.EnumDefinition -> Typed.TypedTerm Proto3.TypeName -> Typed.TypedTerm Proto3.EnumDefinition
enumDefinitionWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumDefinition"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "values"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumDefinition"),
              Model.projectionFieldName = (Model.Name "values")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "options"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumDefinition"),
              Model.projectionFieldName = (Model.Name "options")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the options field of hydra.ext.protobuf.proto3.EnumDefinition
enumDefinitionWithOptions :: Typed.TypedTerm Proto3.EnumDefinition -> Typed.TypedTerm [Proto3.Option] -> Typed.TypedTerm Proto3.EnumDefinition
enumDefinitionWithOptions original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumDefinition"),
      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.protobuf.proto3.EnumDefinition"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "values"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumDefinition"),
              Model.projectionFieldName = (Model.Name "values")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "options"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the values field of hydra.ext.protobuf.proto3.EnumDefinition
enumDefinitionWithValues :: Typed.TypedTerm Proto3.EnumDefinition -> Typed.TypedTerm [Proto3.EnumValue] -> Typed.TypedTerm Proto3.EnumDefinition
enumDefinitionWithValues original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumDefinition"),
      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.protobuf.proto3.EnumDefinition"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "values"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "options"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumDefinition"),
              Model.projectionFieldName = (Model.Name "options")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.protobuf.proto3.EnumValue
enumValue :: Typed.TypedTerm Proto3.EnumValueName -> Typed.TypedTerm Int -> Typed.TypedTerm [Proto3.Option] -> Typed.TypedTerm Proto3.EnumValue
enumValue name number options =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumValue"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "number"),
          Model.fieldTerm = (Typed.unTypedTerm number)},
        Model.Field {
          Model.fieldName = (Model.Name "options"),
          Model.fieldTerm = (Typed.unTypedTerm options)}]}))

-- | DSL name token for hydra.ext.protobuf.proto3.EnumValue
enumValueEnumValue :: Typed.TypedName Proto3.EnumValue
enumValueEnumValue = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.EnumValue")

-- | DSL accessor for the name field of hydra.ext.protobuf.proto3.EnumValue
enumValueName :: Typed.TypedTerm Proto3.EnumValue -> Typed.TypedTerm Proto3.EnumValueName
enumValueName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumValue"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL constructor for the hydra.ext.protobuf.proto3.EnumValueName wrapper
enumValueName2 :: Typed.TypedTerm String -> Typed.TypedTerm Proto3.EnumValueName
enumValueName2 x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumValueName"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.protobuf.proto3.EnumValueName
enumValueNameEnumValueName :: Typed.TypedName Proto3.EnumValueName
enumValueNameEnumValueName = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.EnumValueName")

-- | DSL accessor for the number field of hydra.ext.protobuf.proto3.EnumValue
enumValueNumber :: Typed.TypedTerm Proto3.EnumValue -> Typed.TypedTerm Int
enumValueNumber x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumValue"),
        Model.projectionFieldName = (Model.Name "number")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the options field of hydra.ext.protobuf.proto3.EnumValue
enumValueOptions :: Typed.TypedTerm Proto3.EnumValue -> Typed.TypedTerm [Proto3.Option]
enumValueOptions x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumValue"),
        Model.projectionFieldName = (Model.Name "options")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the name field of hydra.ext.protobuf.proto3.EnumValue
enumValueWithName :: Typed.TypedTerm Proto3.EnumValue -> Typed.TypedTerm Proto3.EnumValueName -> Typed.TypedTerm Proto3.EnumValue
enumValueWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumValue"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "number"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumValue"),
              Model.projectionFieldName = (Model.Name "number")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "options"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumValue"),
              Model.projectionFieldName = (Model.Name "options")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the number field of hydra.ext.protobuf.proto3.EnumValue
enumValueWithNumber :: Typed.TypedTerm Proto3.EnumValue -> Typed.TypedTerm Int -> Typed.TypedTerm Proto3.EnumValue
enumValueWithNumber original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumValue"),
      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.protobuf.proto3.EnumValue"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "number"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "options"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumValue"),
              Model.projectionFieldName = (Model.Name "options")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the options field of hydra.ext.protobuf.proto3.EnumValue
enumValueWithOptions :: Typed.TypedTerm Proto3.EnumValue -> Typed.TypedTerm [Proto3.Option] -> Typed.TypedTerm Proto3.EnumValue
enumValueWithOptions original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumValue"),
      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.protobuf.proto3.EnumValue"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "number"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.EnumValue"),
              Model.projectionFieldName = (Model.Name "number")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "options"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.protobuf.proto3.Field
field :: Typed.TypedTerm Proto3.FieldName -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Proto3.FieldType -> Typed.TypedTerm Int -> Typed.TypedTerm [Proto3.Option] -> Typed.TypedTerm Proto3.Field
field name jsonName type_ number options =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "jsonName"),
          Model.fieldTerm = (Typed.unTypedTerm jsonName)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "number"),
          Model.fieldTerm = (Typed.unTypedTerm number)},
        Model.Field {
          Model.fieldName = (Model.Name "options"),
          Model.fieldTerm = (Typed.unTypedTerm options)}]}))

-- | DSL name token for hydra.ext.protobuf.proto3.Field
fieldField :: Typed.TypedName Proto3.Field
fieldField = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.Field")

-- | DSL accessor for the jsonName field of hydra.ext.protobuf.proto3.Field
fieldJsonName :: Typed.TypedTerm Proto3.Field -> Typed.TypedTerm (Maybe String)
fieldJsonName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"),
        Model.projectionFieldName = (Model.Name "jsonName")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

-- | DSL constructor for the hydra.ext.protobuf.proto3.FieldName wrapper
fieldName2 :: Typed.TypedTerm String -> Typed.TypedTerm Proto3.FieldName
fieldName2 x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.protobuf.proto3.FieldName"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.protobuf.proto3.FieldName
fieldNameFieldName :: Typed.TypedName Proto3.FieldName
fieldNameFieldName = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.FieldName")

-- | DSL accessor for the number field of hydra.ext.protobuf.proto3.Field
fieldNumber :: Typed.TypedTerm Proto3.Field -> Typed.TypedTerm Int
fieldNumber x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"),
        Model.projectionFieldName = (Model.Name "number")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the options field of hydra.ext.protobuf.proto3.Field
fieldOptions :: Typed.TypedTerm Proto3.Field -> Typed.TypedTerm [Proto3.Option]
fieldOptions x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"),
        Model.projectionFieldName = (Model.Name "options")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

-- | DSL name token for hydra.ext.protobuf.proto3.FieldType
fieldTypeFieldType :: Typed.TypedName Proto3.FieldType
fieldTypeFieldType = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.FieldType")

-- | DSL injection for the map variant of hydra.ext.protobuf.proto3.FieldType
fieldTypeMap :: Typed.TypedTerm Proto3.MapType -> Typed.TypedTerm Proto3.FieldType
fieldTypeMap x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.FieldType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "map"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the oneof variant of hydra.ext.protobuf.proto3.FieldType
fieldTypeOneof :: Typed.TypedTerm [Proto3.Field] -> Typed.TypedTerm Proto3.FieldType
fieldTypeOneof x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.FieldType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "oneof"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the repeated variant of hydra.ext.protobuf.proto3.FieldType
fieldTypeRepeated :: Typed.TypedTerm Proto3.SimpleType -> Typed.TypedTerm Proto3.FieldType
fieldTypeRepeated x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.FieldType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "repeated"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the simple variant of hydra.ext.protobuf.proto3.FieldType
fieldTypeSimple :: Typed.TypedTerm Proto3.SimpleType -> Typed.TypedTerm Proto3.FieldType
fieldTypeSimple x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.FieldType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "simple"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL updater for the jsonName field of hydra.ext.protobuf.proto3.Field
fieldWithJsonName :: Typed.TypedTerm Proto3.Field -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Proto3.Field
fieldWithJsonName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.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.protobuf.proto3.Field"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "jsonName"),
          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.protobuf.proto3.Field"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "number"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"),
              Model.projectionFieldName = (Model.Name "number")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "options"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"),
              Model.projectionFieldName = (Model.Name "options")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.protobuf.proto3.Field
fieldWithName :: Typed.TypedTerm Proto3.Field -> Typed.TypedTerm Proto3.FieldName -> Typed.TypedTerm Proto3.Field
fieldWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "jsonName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"),
              Model.projectionFieldName = (Model.Name "jsonName")})),
            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.protobuf.proto3.Field"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "number"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"),
              Model.projectionFieldName = (Model.Name "number")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "options"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"),
              Model.projectionFieldName = (Model.Name "options")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the number field of hydra.ext.protobuf.proto3.Field
fieldWithNumber :: Typed.TypedTerm Proto3.Field -> Typed.TypedTerm Int -> Typed.TypedTerm Proto3.Field
fieldWithNumber original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.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.protobuf.proto3.Field"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "jsonName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"),
              Model.projectionFieldName = (Model.Name "jsonName")})),
            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.protobuf.proto3.Field"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "number"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "options"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"),
              Model.projectionFieldName = (Model.Name "options")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the options field of hydra.ext.protobuf.proto3.Field
fieldWithOptions :: Typed.TypedTerm Proto3.Field -> Typed.TypedTerm [Proto3.Option] -> Typed.TypedTerm Proto3.Field
fieldWithOptions original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.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.protobuf.proto3.Field"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "jsonName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"),
              Model.projectionFieldName = (Model.Name "jsonName")})),
            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.protobuf.proto3.Field"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "number"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"),
              Model.projectionFieldName = (Model.Name "number")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "options"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the type field of hydra.ext.protobuf.proto3.Field
fieldWithType :: Typed.TypedTerm Proto3.Field -> Typed.TypedTerm Proto3.FieldType -> Typed.TypedTerm Proto3.Field
fieldWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.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.protobuf.proto3.Field"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "jsonName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"),
              Model.projectionFieldName = (Model.Name "jsonName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "number"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"),
              Model.projectionFieldName = (Model.Name "number")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "options"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Field"),
              Model.projectionFieldName = (Model.Name "options")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for the hydra.ext.protobuf.proto3.FileReference wrapper
fileReference :: Typed.TypedTerm String -> Typed.TypedTerm Proto3.FileReference
fileReference x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.protobuf.proto3.FileReference"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.protobuf.proto3.FileReference
fileReferenceFileReference :: Typed.TypedName Proto3.FileReference
fileReferenceFileReference = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.FileReference")

-- | DSL constructor for hydra.ext.protobuf.proto3.MapType
mapType :: Typed.TypedTerm Proto3.SimpleType -> Typed.TypedTerm Proto3.SimpleType -> Typed.TypedTerm Proto3.MapType
mapType keys values =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.MapType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "keys"),
          Model.fieldTerm = (Typed.unTypedTerm keys)},
        Model.Field {
          Model.fieldName = (Model.Name "values"),
          Model.fieldTerm = (Typed.unTypedTerm values)}]}))

-- | DSL accessor for the keys field of hydra.ext.protobuf.proto3.MapType
mapTypeKeys :: Typed.TypedTerm Proto3.MapType -> Typed.TypedTerm Proto3.SimpleType
mapTypeKeys x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.MapType"),
        Model.projectionFieldName = (Model.Name "keys")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.protobuf.proto3.MapType
mapTypeMapType :: Typed.TypedName Proto3.MapType
mapTypeMapType = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.MapType")

-- | DSL accessor for the values field of hydra.ext.protobuf.proto3.MapType
mapTypeValues :: Typed.TypedTerm Proto3.MapType -> Typed.TypedTerm Proto3.SimpleType
mapTypeValues x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.MapType"),
        Model.projectionFieldName = (Model.Name "values")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the keys field of hydra.ext.protobuf.proto3.MapType
mapTypeWithKeys :: Typed.TypedTerm Proto3.MapType -> Typed.TypedTerm Proto3.SimpleType -> Typed.TypedTerm Proto3.MapType
mapTypeWithKeys original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.MapType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "keys"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "values"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.MapType"),
              Model.projectionFieldName = (Model.Name "values")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the values field of hydra.ext.protobuf.proto3.MapType
mapTypeWithValues :: Typed.TypedTerm Proto3.MapType -> Typed.TypedTerm Proto3.SimpleType -> Typed.TypedTerm Proto3.MapType
mapTypeWithValues original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.MapType"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "keys"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.MapType"),
              Model.projectionFieldName = (Model.Name "keys")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "values"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.protobuf.proto3.MessageDefinition
messageDefinition :: Typed.TypedTerm Proto3.TypeName -> Typed.TypedTerm [Proto3.Field] -> Typed.TypedTerm [Proto3.Option] -> Typed.TypedTerm Proto3.MessageDefinition
messageDefinition name fields options =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.MessageDefinition"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "fields"),
          Model.fieldTerm = (Typed.unTypedTerm fields)},
        Model.Field {
          Model.fieldName = (Model.Name "options"),
          Model.fieldTerm = (Typed.unTypedTerm options)}]}))

-- | DSL accessor for the fields field of hydra.ext.protobuf.proto3.MessageDefinition
messageDefinitionFields :: Typed.TypedTerm Proto3.MessageDefinition -> Typed.TypedTerm [Proto3.Field]
messageDefinitionFields x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.MessageDefinition"),
        Model.projectionFieldName = (Model.Name "fields")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.protobuf.proto3.MessageDefinition
messageDefinitionMessageDefinition :: Typed.TypedName Proto3.MessageDefinition
messageDefinitionMessageDefinition = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.MessageDefinition")

-- | DSL accessor for the name field of hydra.ext.protobuf.proto3.MessageDefinition
messageDefinitionName :: Typed.TypedTerm Proto3.MessageDefinition -> Typed.TypedTerm Proto3.TypeName
messageDefinitionName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.MessageDefinition"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the options field of hydra.ext.protobuf.proto3.MessageDefinition
messageDefinitionOptions :: Typed.TypedTerm Proto3.MessageDefinition -> Typed.TypedTerm [Proto3.Option]
messageDefinitionOptions x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.MessageDefinition"),
        Model.projectionFieldName = (Model.Name "options")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the fields field of hydra.ext.protobuf.proto3.MessageDefinition
messageDefinitionWithFields :: Typed.TypedTerm Proto3.MessageDefinition -> Typed.TypedTerm [Proto3.Field] -> Typed.TypedTerm Proto3.MessageDefinition
messageDefinitionWithFields original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.MessageDefinition"),
      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.protobuf.proto3.MessageDefinition"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "fields"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "options"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.MessageDefinition"),
              Model.projectionFieldName = (Model.Name "options")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.protobuf.proto3.MessageDefinition
messageDefinitionWithName :: Typed.TypedTerm Proto3.MessageDefinition -> Typed.TypedTerm Proto3.TypeName -> Typed.TypedTerm Proto3.MessageDefinition
messageDefinitionWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.MessageDefinition"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "fields"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.MessageDefinition"),
              Model.projectionFieldName = (Model.Name "fields")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "options"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.MessageDefinition"),
              Model.projectionFieldName = (Model.Name "options")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the options field of hydra.ext.protobuf.proto3.MessageDefinition
messageDefinitionWithOptions :: Typed.TypedTerm Proto3.MessageDefinition -> Typed.TypedTerm [Proto3.Option] -> Typed.TypedTerm Proto3.MessageDefinition
messageDefinitionWithOptions original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.MessageDefinition"),
      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.protobuf.proto3.MessageDefinition"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "fields"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.MessageDefinition"),
              Model.projectionFieldName = (Model.Name "fields")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "options"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.protobuf.proto3.Option
option :: Typed.TypedTerm String -> Typed.TypedTerm Proto3.Value -> Typed.TypedTerm Proto3.Option
option name value =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.Option"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Typed.unTypedTerm value)}]}))

-- | DSL accessor for the name field of hydra.ext.protobuf.proto3.Option
optionName :: Typed.TypedTerm Proto3.Option -> Typed.TypedTerm String
optionName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Option"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.protobuf.proto3.Option
optionOption :: Typed.TypedName Proto3.Option
optionOption = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.Option")

-- | DSL accessor for the value field of hydra.ext.protobuf.proto3.Option
optionValue :: Typed.TypedTerm Proto3.Option -> Typed.TypedTerm Proto3.Value
optionValue x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Option"),
        Model.projectionFieldName = (Model.Name "value")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the name field of hydra.ext.protobuf.proto3.Option
optionWithName :: Typed.TypedTerm Proto3.Option -> Typed.TypedTerm String -> Typed.TypedTerm Proto3.Option
optionWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.Option"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Option"),
              Model.projectionFieldName = (Model.Name "value")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the value field of hydra.ext.protobuf.proto3.Option
optionWithValue :: Typed.TypedTerm Proto3.Option -> Typed.TypedTerm Proto3.Value -> Typed.TypedTerm Proto3.Option
optionWithValue original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.Option"),
      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.protobuf.proto3.Option"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for the hydra.ext.protobuf.proto3.PackageName wrapper
packageName :: Typed.TypedTerm String -> Typed.TypedTerm Proto3.PackageName
packageName x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.protobuf.proto3.PackageName"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.protobuf.proto3.PackageName
packageNamePackageName :: Typed.TypedName Proto3.PackageName
packageNamePackageName = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.PackageName")

-- | DSL constructor for hydra.ext.protobuf.proto3.ProtoFile
protoFile :: Typed.TypedTerm Proto3.PackageName -> Typed.TypedTerm [Proto3.FileReference] -> Typed.TypedTerm [Proto3.Definition] -> Typed.TypedTerm [Proto3.Option] -> Typed.TypedTerm Proto3.ProtoFile
protoFile package imports types options =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "package"),
          Model.fieldTerm = (Typed.unTypedTerm package)},
        Model.Field {
          Model.fieldName = (Model.Name "imports"),
          Model.fieldTerm = (Typed.unTypedTerm imports)},
        Model.Field {
          Model.fieldName = (Model.Name "types"),
          Model.fieldTerm = (Typed.unTypedTerm types)},
        Model.Field {
          Model.fieldName = (Model.Name "options"),
          Model.fieldTerm = (Typed.unTypedTerm options)}]}))

-- | DSL accessor for the imports field of hydra.ext.protobuf.proto3.ProtoFile
protoFileImports :: Typed.TypedTerm Proto3.ProtoFile -> Typed.TypedTerm [Proto3.FileReference]
protoFileImports x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"),
        Model.projectionFieldName = (Model.Name "imports")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the options field of hydra.ext.protobuf.proto3.ProtoFile
protoFileOptions :: Typed.TypedTerm Proto3.ProtoFile -> Typed.TypedTerm [Proto3.Option]
protoFileOptions x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"),
        Model.projectionFieldName = (Model.Name "options")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the package field of hydra.ext.protobuf.proto3.ProtoFile
protoFilePackage :: Typed.TypedTerm Proto3.ProtoFile -> Typed.TypedTerm Proto3.PackageName
protoFilePackage x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"),
        Model.projectionFieldName = (Model.Name "package")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.protobuf.proto3.ProtoFile
protoFileProtoFile :: Typed.TypedName Proto3.ProtoFile
protoFileProtoFile = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.ProtoFile")

-- | DSL accessor for the types field of hydra.ext.protobuf.proto3.ProtoFile
protoFileTypes :: Typed.TypedTerm Proto3.ProtoFile -> Typed.TypedTerm [Proto3.Definition]
protoFileTypes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"),
        Model.projectionFieldName = (Model.Name "types")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the imports field of hydra.ext.protobuf.proto3.ProtoFile
protoFileWithImports :: Typed.TypedTerm Proto3.ProtoFile -> Typed.TypedTerm [Proto3.FileReference] -> Typed.TypedTerm Proto3.ProtoFile
protoFileWithImports original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "package"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"),
              Model.projectionFieldName = (Model.Name "package")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "imports"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "types"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"),
              Model.projectionFieldName = (Model.Name "types")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "options"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"),
              Model.projectionFieldName = (Model.Name "options")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the options field of hydra.ext.protobuf.proto3.ProtoFile
protoFileWithOptions :: Typed.TypedTerm Proto3.ProtoFile -> Typed.TypedTerm [Proto3.Option] -> Typed.TypedTerm Proto3.ProtoFile
protoFileWithOptions original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "package"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"),
              Model.projectionFieldName = (Model.Name "package")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "imports"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"),
              Model.projectionFieldName = (Model.Name "imports")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "types"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"),
              Model.projectionFieldName = (Model.Name "types")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "options"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the package field of hydra.ext.protobuf.proto3.ProtoFile
protoFileWithPackage :: Typed.TypedTerm Proto3.ProtoFile -> Typed.TypedTerm Proto3.PackageName -> Typed.TypedTerm Proto3.ProtoFile
protoFileWithPackage original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "package"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "imports"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"),
              Model.projectionFieldName = (Model.Name "imports")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "types"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"),
              Model.projectionFieldName = (Model.Name "types")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "options"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"),
              Model.projectionFieldName = (Model.Name "options")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the types field of hydra.ext.protobuf.proto3.ProtoFile
protoFileWithTypes :: Typed.TypedTerm Proto3.ProtoFile -> Typed.TypedTerm [Proto3.Definition] -> Typed.TypedTerm Proto3.ProtoFile
protoFileWithTypes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "package"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"),
              Model.projectionFieldName = (Model.Name "package")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "imports"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"),
              Model.projectionFieldName = (Model.Name "imports")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "types"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "options"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ProtoFile"),
              Model.projectionFieldName = (Model.Name "options")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the bool variant of hydra.ext.protobuf.proto3.ScalarType
scalarTypeBool :: Typed.TypedTerm Proto3.ScalarType
scalarTypeBool =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ScalarType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "bool"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the bytes variant of hydra.ext.protobuf.proto3.ScalarType
scalarTypeBytes :: Typed.TypedTerm Proto3.ScalarType
scalarTypeBytes =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ScalarType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "bytes"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the double variant of hydra.ext.protobuf.proto3.ScalarType
scalarTypeDouble :: Typed.TypedTerm Proto3.ScalarType
scalarTypeDouble =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ScalarType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "double"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the fixed32 variant of hydra.ext.protobuf.proto3.ScalarType
scalarTypeFixed32 :: Typed.TypedTerm Proto3.ScalarType
scalarTypeFixed32 =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ScalarType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "fixed32"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the fixed64 variant of hydra.ext.protobuf.proto3.ScalarType
scalarTypeFixed64 :: Typed.TypedTerm Proto3.ScalarType
scalarTypeFixed64 =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ScalarType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "fixed64"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the float variant of hydra.ext.protobuf.proto3.ScalarType
scalarTypeFloat :: Typed.TypedTerm Proto3.ScalarType
scalarTypeFloat =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ScalarType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "float"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the int32 variant of hydra.ext.protobuf.proto3.ScalarType
scalarTypeInt32 :: Typed.TypedTerm Proto3.ScalarType
scalarTypeInt32 =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ScalarType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "int32"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the int64 variant of hydra.ext.protobuf.proto3.ScalarType
scalarTypeInt64 :: Typed.TypedTerm Proto3.ScalarType
scalarTypeInt64 =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ScalarType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "int64"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.protobuf.proto3.ScalarType
scalarTypeScalarType :: Typed.TypedName Proto3.ScalarType
scalarTypeScalarType = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.ScalarType")

-- | DSL injection for the sfixed32 variant of hydra.ext.protobuf.proto3.ScalarType
scalarTypeSfixed32 :: Typed.TypedTerm Proto3.ScalarType
scalarTypeSfixed32 =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ScalarType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "sfixed32"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the sfixed64 variant of hydra.ext.protobuf.proto3.ScalarType
scalarTypeSfixed64 :: Typed.TypedTerm Proto3.ScalarType
scalarTypeSfixed64 =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ScalarType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "sfixed64"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the sint32 variant of hydra.ext.protobuf.proto3.ScalarType
scalarTypeSint32 :: Typed.TypedTerm Proto3.ScalarType
scalarTypeSint32 =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ScalarType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "sint32"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the sint64 variant of hydra.ext.protobuf.proto3.ScalarType
scalarTypeSint64 :: Typed.TypedTerm Proto3.ScalarType
scalarTypeSint64 =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ScalarType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "sint64"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the string variant of hydra.ext.protobuf.proto3.ScalarType
scalarTypeString :: Typed.TypedTerm Proto3.ScalarType
scalarTypeString =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ScalarType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "string"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the uint32 variant of hydra.ext.protobuf.proto3.ScalarType
scalarTypeUint32 :: Typed.TypedTerm Proto3.ScalarType
scalarTypeUint32 =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ScalarType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "uint32"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the uint64 variant of hydra.ext.protobuf.proto3.ScalarType
scalarTypeUint64 :: Typed.TypedTerm Proto3.ScalarType
scalarTypeUint64 =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.ScalarType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "uint64"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the reference variant of hydra.ext.protobuf.proto3.SimpleType
simpleTypeReference :: Typed.TypedTerm Proto3.TypeName -> Typed.TypedTerm Proto3.SimpleType
simpleTypeReference x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.SimpleType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "reference"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the scalar variant of hydra.ext.protobuf.proto3.SimpleType
simpleTypeScalar :: Typed.TypedTerm Proto3.ScalarType -> Typed.TypedTerm Proto3.SimpleType
simpleTypeScalar x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.SimpleType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "scalar"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.protobuf.proto3.SimpleType
simpleTypeSimpleType :: Typed.TypedName Proto3.SimpleType
simpleTypeSimpleType = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.SimpleType")

-- | DSL constructor for the hydra.ext.protobuf.proto3.TypeName wrapper
typeName :: Typed.TypedTerm String -> Typed.TypedTerm Proto3.TypeName
typeName x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.protobuf.proto3.TypeName"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.protobuf.proto3.TypeName
typeNameTypeName :: Typed.TypedName Proto3.TypeName
typeNameTypeName = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.TypeName")

-- | DSL constructor for the hydra.ext.protobuf.proto3.TypeReference wrapper
typeReference :: Typed.TypedTerm String -> Typed.TypedTerm Proto3.TypeReference
typeReference x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.protobuf.proto3.TypeReference"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.protobuf.proto3.TypeReference
typeReferenceTypeReference :: Typed.TypedName Proto3.TypeReference
typeReferenceTypeReference = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.TypeReference")

-- | DSL accessor for the body of hydra.ext.protobuf.proto3.EnumValueName
unEnumValueName :: Typed.TypedTerm Proto3.EnumValueName -> Typed.TypedTerm String
unEnumValueName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.protobuf.proto3.EnumValueName")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.protobuf.proto3.FieldName
unFieldName :: Typed.TypedTerm Proto3.FieldName -> Typed.TypedTerm String
unFieldName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.protobuf.proto3.FieldName")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.protobuf.proto3.FileReference
unFileReference :: Typed.TypedTerm Proto3.FileReference -> Typed.TypedTerm String
unFileReference x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.protobuf.proto3.FileReference")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.protobuf.proto3.PackageName
unPackageName :: Typed.TypedTerm Proto3.PackageName -> Typed.TypedTerm String
unPackageName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.protobuf.proto3.PackageName")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.protobuf.proto3.TypeName
unTypeName :: Typed.TypedTerm Proto3.TypeName -> Typed.TypedTerm String
unTypeName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.protobuf.proto3.TypeName")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.protobuf.proto3.TypeReference
unTypeReference :: Typed.TypedTerm Proto3.TypeReference -> Typed.TypedTerm String
unTypeReference x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.protobuf.proto3.TypeReference")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL injection for the boolean variant of hydra.ext.protobuf.proto3.Value
valueBoolean :: Typed.TypedTerm Bool -> Typed.TypedTerm Proto3.Value
valueBoolean x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Value"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "boolean"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the string variant of hydra.ext.protobuf.proto3.Value
valueString :: Typed.TypedTerm String -> Typed.TypedTerm Proto3.Value
valueString x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.protobuf.proto3.Value"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "string"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.protobuf.proto3.Value
valueValue :: Typed.TypedName Proto3.Value
valueValue = Typed.TypedName (Model.Name "hydra.ext.protobuf.proto3.Value")