hydra-ext-0.18.0: src/main/haskell/Hydra/Ext/Dsl/Pegasus/Pdl.hs

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

-- | DSL functions for hydra.ext.pegasus.pdl

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

-- | DSL constructor for hydra.ext.pegasus.pdl.Annotations
annotations :: Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Bool -> Typed.TypedTerm Pdl.Annotations
annotations doc deprecated =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.Annotations"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "doc"),
          Model.fieldTerm = (Typed.unTypedTerm doc)},
        Model.Field {
          Model.fieldName = (Model.Name "deprecated"),
          Model.fieldTerm = (Typed.unTypedTerm deprecated)}]}))

-- | DSL name token for hydra.ext.pegasus.pdl.Annotations
annotationsAnnotations :: Typed.TypedName Pdl.Annotations
annotationsAnnotations = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.Annotations")

-- | DSL accessor for the deprecated field of hydra.ext.pegasus.pdl.Annotations
annotationsDeprecated :: Typed.TypedTerm Pdl.Annotations -> Typed.TypedTerm Bool
annotationsDeprecated x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.Annotations"),
        Model.projectionFieldName = (Model.Name "deprecated")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the doc field of hydra.ext.pegasus.pdl.Annotations
annotationsDoc :: Typed.TypedTerm Pdl.Annotations -> Typed.TypedTerm (Maybe String)
annotationsDoc x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.Annotations"),
        Model.projectionFieldName = (Model.Name "doc")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the deprecated field of hydra.ext.pegasus.pdl.Annotations
annotationsWithDeprecated :: Typed.TypedTerm Pdl.Annotations -> Typed.TypedTerm Bool -> Typed.TypedTerm Pdl.Annotations
annotationsWithDeprecated original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.Annotations"),
      Model.recordFields = [
        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.pegasus.pdl.Annotations"),
              Model.projectionFieldName = (Model.Name "doc")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "deprecated"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the doc field of hydra.ext.pegasus.pdl.Annotations
annotationsWithDoc :: Typed.TypedTerm Pdl.Annotations -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Pdl.Annotations
annotationsWithDoc original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.Annotations"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "doc"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "deprecated"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.Annotations"),
              Model.projectionFieldName = (Model.Name "deprecated")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.pegasus.pdl.EnumField
enumField :: Typed.TypedTerm Pdl.EnumFieldName -> Typed.TypedTerm Pdl.Annotations -> Typed.TypedTerm Pdl.EnumField
enumField name annotations =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.EnumField"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "annotations"),
          Model.fieldTerm = (Typed.unTypedTerm annotations)}]}))

-- | DSL accessor for the annotations field of hydra.ext.pegasus.pdl.EnumField
enumFieldAnnotations :: Typed.TypedTerm Pdl.EnumField -> Typed.TypedTerm Pdl.Annotations
enumFieldAnnotations x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.EnumField"),
        Model.projectionFieldName = (Model.Name "annotations")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.pegasus.pdl.EnumField
enumFieldEnumField :: Typed.TypedName Pdl.EnumField
enumFieldEnumField = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.EnumField")

-- | DSL accessor for the name field of hydra.ext.pegasus.pdl.EnumField
enumFieldName :: Typed.TypedTerm Pdl.EnumField -> Typed.TypedTerm Pdl.EnumFieldName
enumFieldName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.EnumField"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL constructor for the hydra.ext.pegasus.pdl.EnumFieldName wrapper
enumFieldName2 :: Typed.TypedTerm String -> Typed.TypedTerm Pdl.EnumFieldName
enumFieldName2 x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.pegasus.pdl.EnumFieldName"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.pegasus.pdl.EnumFieldName
enumFieldNameEnumFieldName :: Typed.TypedName Pdl.EnumFieldName
enumFieldNameEnumFieldName = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.EnumFieldName")

-- | DSL updater for the annotations field of hydra.ext.pegasus.pdl.EnumField
enumFieldWithAnnotations :: Typed.TypedTerm Pdl.EnumField -> Typed.TypedTerm Pdl.Annotations -> Typed.TypedTerm Pdl.EnumField
enumFieldWithAnnotations original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.EnumField"),
      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.pegasus.pdl.EnumField"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "annotations"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the name field of hydra.ext.pegasus.pdl.EnumField
enumFieldWithName :: Typed.TypedTerm Pdl.EnumField -> Typed.TypedTerm Pdl.EnumFieldName -> Typed.TypedTerm Pdl.EnumField
enumFieldWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.EnumField"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          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.pegasus.pdl.EnumField"),
              Model.projectionFieldName = (Model.Name "annotations")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.pegasus.pdl.EnumSchema
enumSchema :: Typed.TypedTerm [Pdl.EnumField] -> Typed.TypedTerm Pdl.EnumSchema
enumSchema fields =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.EnumSchema"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "fields"),
          Model.fieldTerm = (Typed.unTypedTerm fields)}]}))

-- | DSL name token for hydra.ext.pegasus.pdl.EnumSchema
enumSchemaEnumSchema :: Typed.TypedName Pdl.EnumSchema
enumSchemaEnumSchema = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.EnumSchema")

-- | DSL accessor for the fields field of hydra.ext.pegasus.pdl.EnumSchema
enumSchemaFields :: Typed.TypedTerm Pdl.EnumSchema -> Typed.TypedTerm [Pdl.EnumField]
enumSchemaFields x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.EnumSchema"),
        Model.projectionFieldName = (Model.Name "fields")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the fields field of hydra.ext.pegasus.pdl.EnumSchema
enumSchemaWithFields :: Typed.TypedTerm Pdl.EnumSchema -> Typed.TypedTerm [Pdl.EnumField] -> Typed.TypedTerm Pdl.EnumSchema
enumSchemaWithFields original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.EnumSchema"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "fields"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for the hydra.ext.pegasus.pdl.FieldName wrapper
fieldName :: Typed.TypedTerm String -> Typed.TypedTerm Pdl.FieldName
fieldName x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.pegasus.pdl.FieldName"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.pegasus.pdl.FieldName
fieldNameFieldName :: Typed.TypedName Pdl.FieldName
fieldNameFieldName = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.FieldName")

-- | DSL constructor for the hydra.ext.pegasus.pdl.Name wrapper
name :: Typed.TypedTerm String -> Typed.TypedTerm Pdl.Name
name x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.pegasus.pdl.Name"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.pegasus.pdl.Name
nameName :: Typed.TypedName Pdl.Name
nameName = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.Name")

-- | DSL constructor for hydra.ext.pegasus.pdl.NamedSchema
namedSchema :: Typed.TypedTerm Pdl.QualifiedName -> Typed.TypedTerm Pdl.NamedSchemaType -> Typed.TypedTerm Pdl.Annotations -> Typed.TypedTerm Pdl.NamedSchema
namedSchema qualifiedName type_ annotations =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.NamedSchema"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "qualifiedName"),
          Model.fieldTerm = (Typed.unTypedTerm qualifiedName)},
        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 annotations field of hydra.ext.pegasus.pdl.NamedSchema
namedSchemaAnnotations :: Typed.TypedTerm Pdl.NamedSchema -> Typed.TypedTerm Pdl.Annotations
namedSchemaAnnotations x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.NamedSchema"),
        Model.projectionFieldName = (Model.Name "annotations")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.pegasus.pdl.NamedSchema
namedSchemaNamedSchema :: Typed.TypedName Pdl.NamedSchema
namedSchemaNamedSchema = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.NamedSchema")

-- | DSL accessor for the qualifiedName field of hydra.ext.pegasus.pdl.NamedSchema
namedSchemaQualifiedName :: Typed.TypedTerm Pdl.NamedSchema -> Typed.TypedTerm Pdl.QualifiedName
namedSchemaQualifiedName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.NamedSchema"),
        Model.projectionFieldName = (Model.Name "qualifiedName")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.pegasus.pdl.NamedSchema
namedSchemaType :: Typed.TypedTerm Pdl.NamedSchema -> Typed.TypedTerm Pdl.NamedSchemaType
namedSchemaType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.NamedSchema"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL injection for the enum variant of hydra.ext.pegasus.pdl.NamedSchemaType
namedSchemaTypeEnum :: Typed.TypedTerm Pdl.EnumSchema -> Typed.TypedTerm Pdl.NamedSchemaType
namedSchemaTypeEnum x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.NamedSchemaType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "enum"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.pegasus.pdl.NamedSchemaType
namedSchemaTypeNamedSchemaType :: Typed.TypedName Pdl.NamedSchemaType
namedSchemaTypeNamedSchemaType = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.NamedSchemaType")

-- | DSL injection for the record variant of hydra.ext.pegasus.pdl.NamedSchemaType
namedSchemaTypeRecord :: Typed.TypedTerm Pdl.RecordSchema -> Typed.TypedTerm Pdl.NamedSchemaType
namedSchemaTypeRecord x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.NamedSchemaType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "record"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the typeref variant of hydra.ext.pegasus.pdl.NamedSchemaType
namedSchemaTypeTyperef :: Typed.TypedTerm Pdl.Schema -> Typed.TypedTerm Pdl.NamedSchemaType
namedSchemaTypeTyperef x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.NamedSchemaType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "typeref"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL updater for the annotations field of hydra.ext.pegasus.pdl.NamedSchema
namedSchemaWithAnnotations :: Typed.TypedTerm Pdl.NamedSchema -> Typed.TypedTerm Pdl.Annotations -> Typed.TypedTerm Pdl.NamedSchema
namedSchemaWithAnnotations original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.NamedSchema"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "qualifiedName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.NamedSchema"),
              Model.projectionFieldName = (Model.Name "qualifiedName")})),
            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.pegasus.pdl.NamedSchema"),
              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 qualifiedName field of hydra.ext.pegasus.pdl.NamedSchema
namedSchemaWithQualifiedName :: Typed.TypedTerm Pdl.NamedSchema -> Typed.TypedTerm Pdl.QualifiedName -> Typed.TypedTerm Pdl.NamedSchema
namedSchemaWithQualifiedName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.NamedSchema"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "qualifiedName"),
          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.pegasus.pdl.NamedSchema"),
              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.pegasus.pdl.NamedSchema"),
              Model.projectionFieldName = (Model.Name "annotations")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.pegasus.pdl.NamedSchema
namedSchemaWithType :: Typed.TypedTerm Pdl.NamedSchema -> Typed.TypedTerm Pdl.NamedSchemaType -> Typed.TypedTerm Pdl.NamedSchema
namedSchemaWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.NamedSchema"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "qualifiedName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.NamedSchema"),
              Model.projectionFieldName = (Model.Name "qualifiedName")})),
            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.pegasus.pdl.NamedSchema"),
              Model.projectionFieldName = (Model.Name "annotations")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for the hydra.ext.pegasus.pdl.Namespace wrapper
namespace :: Typed.TypedTerm String -> Typed.TypedTerm Pdl.Namespace
namespace x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.pegasus.pdl.Namespace"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.pegasus.pdl.Namespace
namespaceNamespace :: Typed.TypedName Pdl.Namespace
namespaceNamespace = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.Namespace")

-- | DSL constructor for the hydra.ext.pegasus.pdl.Package wrapper
package :: Typed.TypedTerm String -> Typed.TypedTerm Pdl.Package
package x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.pegasus.pdl.Package"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.pegasus.pdl.Package
packagePackage :: Typed.TypedName Pdl.Package
packagePackage = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.Package")

-- | DSL injection for the boolean variant of hydra.ext.pegasus.pdl.PrimitiveType
primitiveTypeBoolean :: Typed.TypedTerm Pdl.PrimitiveType
primitiveTypeBoolean =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.PrimitiveType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "boolean"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the bytes variant of hydra.ext.pegasus.pdl.PrimitiveType
primitiveTypeBytes :: Typed.TypedTerm Pdl.PrimitiveType
primitiveTypeBytes =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.PrimitiveType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "bytes"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the double variant of hydra.ext.pegasus.pdl.PrimitiveType
primitiveTypeDouble :: Typed.TypedTerm Pdl.PrimitiveType
primitiveTypeDouble =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.PrimitiveType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "double"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the float variant of hydra.ext.pegasus.pdl.PrimitiveType
primitiveTypeFloat :: Typed.TypedTerm Pdl.PrimitiveType
primitiveTypeFloat =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.PrimitiveType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "float"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the int variant of hydra.ext.pegasus.pdl.PrimitiveType
primitiveTypeInt :: Typed.TypedTerm Pdl.PrimitiveType
primitiveTypeInt =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.PrimitiveType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "int"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the long variant of hydra.ext.pegasus.pdl.PrimitiveType
primitiveTypeLong :: Typed.TypedTerm Pdl.PrimitiveType
primitiveTypeLong =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.PrimitiveType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "long"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.pegasus.pdl.PrimitiveType
primitiveTypePrimitiveType :: Typed.TypedName Pdl.PrimitiveType
primitiveTypePrimitiveType = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.PrimitiveType")

-- | DSL injection for the string variant of hydra.ext.pegasus.pdl.PrimitiveType
primitiveTypeString :: Typed.TypedTerm Pdl.PrimitiveType
primitiveTypeString =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.PrimitiveType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "string"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL constructor for hydra.ext.pegasus.pdl.Property
property :: Typed.TypedTerm Pdl.PropertyKey -> Typed.TypedTerm (Maybe JsonModel.Value) -> Typed.TypedTerm Pdl.Property
property key value =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.Property"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "key"),
          Model.fieldTerm = (Typed.unTypedTerm key)},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Typed.unTypedTerm value)}]}))

-- | DSL accessor for the key field of hydra.ext.pegasus.pdl.Property
propertyKey :: Typed.TypedTerm Pdl.Property -> Typed.TypedTerm Pdl.PropertyKey
propertyKey x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.Property"),
        Model.projectionFieldName = (Model.Name "key")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL constructor for the hydra.ext.pegasus.pdl.PropertyKey wrapper
propertyKey2 :: Typed.TypedTerm String -> Typed.TypedTerm Pdl.PropertyKey
propertyKey2 x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.pegasus.pdl.PropertyKey"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.pegasus.pdl.PropertyKey
propertyKeyPropertyKey :: Typed.TypedName Pdl.PropertyKey
propertyKeyPropertyKey = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.PropertyKey")

-- | DSL name token for hydra.ext.pegasus.pdl.Property
propertyProperty :: Typed.TypedName Pdl.Property
propertyProperty = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.Property")

-- | DSL accessor for the value field of hydra.ext.pegasus.pdl.Property
propertyValue :: Typed.TypedTerm Pdl.Property -> Typed.TypedTerm (Maybe JsonModel.Value)
propertyValue x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.Property"),
        Model.projectionFieldName = (Model.Name "value")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the key field of hydra.ext.pegasus.pdl.Property
propertyWithKey :: Typed.TypedTerm Pdl.Property -> Typed.TypedTerm Pdl.PropertyKey -> Typed.TypedTerm Pdl.Property
propertyWithKey original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.Property"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "key"),
          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.pegasus.pdl.Property"),
              Model.projectionFieldName = (Model.Name "value")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the value field of hydra.ext.pegasus.pdl.Property
propertyWithValue :: Typed.TypedTerm Pdl.Property -> Typed.TypedTerm (Maybe JsonModel.Value) -> Typed.TypedTerm Pdl.Property
propertyWithValue original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.Property"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "key"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.Property"),
              Model.projectionFieldName = (Model.Name "key")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.pegasus.pdl.QualifiedName
qualifiedName :: Typed.TypedTerm Pdl.Name -> Typed.TypedTerm (Maybe Pdl.Namespace) -> Typed.TypedTerm Pdl.QualifiedName
qualifiedName name namespace =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.QualifiedName"),
      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)}]}))

-- | DSL accessor for the name field of hydra.ext.pegasus.pdl.QualifiedName
qualifiedNameName :: Typed.TypedTerm Pdl.QualifiedName -> Typed.TypedTerm Pdl.Name
qualifiedNameName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.QualifiedName"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the namespace field of hydra.ext.pegasus.pdl.QualifiedName
qualifiedNameNamespace :: Typed.TypedTerm Pdl.QualifiedName -> Typed.TypedTerm (Maybe Pdl.Namespace)
qualifiedNameNamespace x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.QualifiedName"),
        Model.projectionFieldName = (Model.Name "namespace")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.pegasus.pdl.QualifiedName
qualifiedNameQualifiedName :: Typed.TypedName Pdl.QualifiedName
qualifiedNameQualifiedName = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.QualifiedName")

-- | DSL updater for the name field of hydra.ext.pegasus.pdl.QualifiedName
qualifiedNameWithName :: Typed.TypedTerm Pdl.QualifiedName -> Typed.TypedTerm Pdl.Name -> Typed.TypedTerm Pdl.QualifiedName
qualifiedNameWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.QualifiedName"),
      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.pegasus.pdl.QualifiedName"),
              Model.projectionFieldName = (Model.Name "namespace")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the namespace field of hydra.ext.pegasus.pdl.QualifiedName
qualifiedNameWithNamespace :: Typed.TypedTerm Pdl.QualifiedName -> Typed.TypedTerm (Maybe Pdl.Namespace) -> Typed.TypedTerm Pdl.QualifiedName
qualifiedNameWithNamespace original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.QualifiedName"),
      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.pegasus.pdl.QualifiedName"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "namespace"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.pegasus.pdl.RecordField
recordField :: Typed.TypedTerm Pdl.FieldName -> Typed.TypedTerm Pdl.Schema -> Typed.TypedTerm Bool -> Typed.TypedTerm (Maybe JsonModel.Value) -> Typed.TypedTerm Pdl.Annotations -> Typed.TypedTerm Pdl.RecordField
recordField name value optional default_ annotations =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"),
      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)},
        Model.Field {
          Model.fieldName = (Model.Name "optional"),
          Model.fieldTerm = (Typed.unTypedTerm optional)},
        Model.Field {
          Model.fieldName = (Model.Name "default"),
          Model.fieldTerm = (Typed.unTypedTerm default_)},
        Model.Field {
          Model.fieldName = (Model.Name "annotations"),
          Model.fieldTerm = (Typed.unTypedTerm annotations)}]}))

-- | DSL accessor for the annotations field of hydra.ext.pegasus.pdl.RecordField
recordFieldAnnotations :: Typed.TypedTerm Pdl.RecordField -> Typed.TypedTerm Pdl.Annotations
recordFieldAnnotations x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"),
        Model.projectionFieldName = (Model.Name "annotations")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the default field of hydra.ext.pegasus.pdl.RecordField
recordFieldDefault :: Typed.TypedTerm Pdl.RecordField -> Typed.TypedTerm (Maybe JsonModel.Value)
recordFieldDefault x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"),
        Model.projectionFieldName = (Model.Name "default")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the name field of hydra.ext.pegasus.pdl.RecordField
recordFieldName :: Typed.TypedTerm Pdl.RecordField -> Typed.TypedTerm Pdl.FieldName
recordFieldName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the optional field of hydra.ext.pegasus.pdl.RecordField
recordFieldOptional :: Typed.TypedTerm Pdl.RecordField -> Typed.TypedTerm Bool
recordFieldOptional x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"),
        Model.projectionFieldName = (Model.Name "optional")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.pegasus.pdl.RecordField
recordFieldRecordField :: Typed.TypedName Pdl.RecordField
recordFieldRecordField = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.RecordField")

-- | DSL accessor for the value field of hydra.ext.pegasus.pdl.RecordField
recordFieldValue :: Typed.TypedTerm Pdl.RecordField -> Typed.TypedTerm Pdl.Schema
recordFieldValue x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"),
        Model.projectionFieldName = (Model.Name "value")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the annotations field of hydra.ext.pegasus.pdl.RecordField
recordFieldWithAnnotations :: Typed.TypedTerm Pdl.RecordField -> Typed.TypedTerm Pdl.Annotations -> Typed.TypedTerm Pdl.RecordField
recordFieldWithAnnotations original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"),
      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.pegasus.pdl.RecordField"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        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.pegasus.pdl.RecordField"),
              Model.projectionFieldName = (Model.Name "value")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "optional"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"),
              Model.projectionFieldName = (Model.Name "optional")})),
            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.pegasus.pdl.RecordField"),
              Model.projectionFieldName = (Model.Name "default")})),
            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.pegasus.pdl.RecordField
recordFieldWithDefault :: Typed.TypedTerm Pdl.RecordField -> Typed.TypedTerm (Maybe JsonModel.Value) -> Typed.TypedTerm Pdl.RecordField
recordFieldWithDefault original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"),
      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.pegasus.pdl.RecordField"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        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.pegasus.pdl.RecordField"),
              Model.projectionFieldName = (Model.Name "value")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "optional"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"),
              Model.projectionFieldName = (Model.Name "optional")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "default"),
          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.pegasus.pdl.RecordField"),
              Model.projectionFieldName = (Model.Name "annotations")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.pegasus.pdl.RecordField
recordFieldWithName :: Typed.TypedTerm Pdl.RecordField -> Typed.TypedTerm Pdl.FieldName -> Typed.TypedTerm Pdl.RecordField
recordFieldWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"),
      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.pegasus.pdl.RecordField"),
              Model.projectionFieldName = (Model.Name "value")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "optional"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"),
              Model.projectionFieldName = (Model.Name "optional")})),
            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.pegasus.pdl.RecordField"),
              Model.projectionFieldName = (Model.Name "default")})),
            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.pegasus.pdl.RecordField"),
              Model.projectionFieldName = (Model.Name "annotations")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the optional field of hydra.ext.pegasus.pdl.RecordField
recordFieldWithOptional :: Typed.TypedTerm Pdl.RecordField -> Typed.TypedTerm Bool -> Typed.TypedTerm Pdl.RecordField
recordFieldWithOptional original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"),
      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.pegasus.pdl.RecordField"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        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.pegasus.pdl.RecordField"),
              Model.projectionFieldName = (Model.Name "value")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "optional"),
          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.pegasus.pdl.RecordField"),
              Model.projectionFieldName = (Model.Name "default")})),
            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.pegasus.pdl.RecordField"),
              Model.projectionFieldName = (Model.Name "annotations")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the value field of hydra.ext.pegasus.pdl.RecordField
recordFieldWithValue :: Typed.TypedTerm Pdl.RecordField -> Typed.TypedTerm Pdl.Schema -> Typed.TypedTerm Pdl.RecordField
recordFieldWithValue original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"),
      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.pegasus.pdl.RecordField"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "optional"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordField"),
              Model.projectionFieldName = (Model.Name "optional")})),
            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.pegasus.pdl.RecordField"),
              Model.projectionFieldName = (Model.Name "default")})),
            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.pegasus.pdl.RecordField"),
              Model.projectionFieldName = (Model.Name "annotations")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.pegasus.pdl.RecordSchema
recordSchema :: Typed.TypedTerm [Pdl.RecordField] -> Typed.TypedTerm [Pdl.NamedSchema] -> Typed.TypedTerm Pdl.RecordSchema
recordSchema fields includes =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordSchema"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "fields"),
          Model.fieldTerm = (Typed.unTypedTerm fields)},
        Model.Field {
          Model.fieldName = (Model.Name "includes"),
          Model.fieldTerm = (Typed.unTypedTerm includes)}]}))

-- | DSL accessor for the fields field of hydra.ext.pegasus.pdl.RecordSchema
recordSchemaFields :: Typed.TypedTerm Pdl.RecordSchema -> Typed.TypedTerm [Pdl.RecordField]
recordSchemaFields x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordSchema"),
        Model.projectionFieldName = (Model.Name "fields")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the includes field of hydra.ext.pegasus.pdl.RecordSchema
recordSchemaIncludes :: Typed.TypedTerm Pdl.RecordSchema -> Typed.TypedTerm [Pdl.NamedSchema]
recordSchemaIncludes x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordSchema"),
        Model.projectionFieldName = (Model.Name "includes")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.pegasus.pdl.RecordSchema
recordSchemaRecordSchema :: Typed.TypedName Pdl.RecordSchema
recordSchemaRecordSchema = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.RecordSchema")

-- | DSL updater for the fields field of hydra.ext.pegasus.pdl.RecordSchema
recordSchemaWithFields :: Typed.TypedTerm Pdl.RecordSchema -> Typed.TypedTerm [Pdl.RecordField] -> Typed.TypedTerm Pdl.RecordSchema
recordSchemaWithFields original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordSchema"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "fields"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "includes"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordSchema"),
              Model.projectionFieldName = (Model.Name "includes")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the includes field of hydra.ext.pegasus.pdl.RecordSchema
recordSchemaWithIncludes :: Typed.TypedTerm Pdl.RecordSchema -> Typed.TypedTerm [Pdl.NamedSchema] -> Typed.TypedTerm Pdl.RecordSchema
recordSchemaWithIncludes original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.RecordSchema"),
      Model.recordFields = [
        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.pegasus.pdl.RecordSchema"),
              Model.projectionFieldName = (Model.Name "fields")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "includes"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

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

-- | DSL constructor for hydra.ext.pegasus.pdl.SchemaFile
schemaFile :: Typed.TypedTerm Pdl.Namespace -> Typed.TypedTerm (Maybe Pdl.Package) -> Typed.TypedTerm [Pdl.QualifiedName] -> Typed.TypedTerm [Pdl.NamedSchema] -> Typed.TypedTerm Pdl.SchemaFile
schemaFile namespace package imports schemas =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespace"),
          Model.fieldTerm = (Typed.unTypedTerm namespace)},
        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 "schemas"),
          Model.fieldTerm = (Typed.unTypedTerm schemas)}]}))

-- | DSL accessor for the imports field of hydra.ext.pegasus.pdl.SchemaFile
schemaFileImports :: Typed.TypedTerm Pdl.SchemaFile -> Typed.TypedTerm [Pdl.QualifiedName]
schemaFileImports x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"),
        Model.projectionFieldName = (Model.Name "imports")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the namespace field of hydra.ext.pegasus.pdl.SchemaFile
schemaFileNamespace :: Typed.TypedTerm Pdl.SchemaFile -> Typed.TypedTerm Pdl.Namespace
schemaFileNamespace x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"),
        Model.projectionFieldName = (Model.Name "namespace")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the package field of hydra.ext.pegasus.pdl.SchemaFile
schemaFilePackage :: Typed.TypedTerm Pdl.SchemaFile -> Typed.TypedTerm (Maybe Pdl.Package)
schemaFilePackage x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"),
        Model.projectionFieldName = (Model.Name "package")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.pegasus.pdl.SchemaFile
schemaFileSchemaFile :: Typed.TypedName Pdl.SchemaFile
schemaFileSchemaFile = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.SchemaFile")

-- | DSL accessor for the schemas field of hydra.ext.pegasus.pdl.SchemaFile
schemaFileSchemas :: Typed.TypedTerm Pdl.SchemaFile -> Typed.TypedTerm [Pdl.NamedSchema]
schemaFileSchemas x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"),
        Model.projectionFieldName = (Model.Name "schemas")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the imports field of hydra.ext.pegasus.pdl.SchemaFile
schemaFileWithImports :: Typed.TypedTerm Pdl.SchemaFile -> Typed.TypedTerm [Pdl.QualifiedName] -> Typed.TypedTerm Pdl.SchemaFile
schemaFileWithImports original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"),
      Model.recordFields = [
        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.pegasus.pdl.SchemaFile"),
              Model.projectionFieldName = (Model.Name "namespace")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        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.pegasus.pdl.SchemaFile"),
              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 "schemas"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"),
              Model.projectionFieldName = (Model.Name "schemas")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the namespace field of hydra.ext.pegasus.pdl.SchemaFile
schemaFileWithNamespace :: Typed.TypedTerm Pdl.SchemaFile -> Typed.TypedTerm Pdl.Namespace -> Typed.TypedTerm Pdl.SchemaFile
schemaFileWithNamespace original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "namespace"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        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.pegasus.pdl.SchemaFile"),
              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.pegasus.pdl.SchemaFile"),
              Model.projectionFieldName = (Model.Name "imports")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schemas"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"),
              Model.projectionFieldName = (Model.Name "schemas")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the package field of hydra.ext.pegasus.pdl.SchemaFile
schemaFileWithPackage :: Typed.TypedTerm Pdl.SchemaFile -> Typed.TypedTerm (Maybe Pdl.Package) -> Typed.TypedTerm Pdl.SchemaFile
schemaFileWithPackage original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"),
      Model.recordFields = [
        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.pegasus.pdl.SchemaFile"),
              Model.projectionFieldName = (Model.Name "namespace")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        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.pegasus.pdl.SchemaFile"),
              Model.projectionFieldName = (Model.Name "imports")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schemas"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"),
              Model.projectionFieldName = (Model.Name "schemas")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the schemas field of hydra.ext.pegasus.pdl.SchemaFile
schemaFileWithSchemas :: Typed.TypedTerm Pdl.SchemaFile -> Typed.TypedTerm [Pdl.NamedSchema] -> Typed.TypedTerm Pdl.SchemaFile
schemaFileWithSchemas original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.SchemaFile"),
      Model.recordFields = [
        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.pegasus.pdl.SchemaFile"),
              Model.projectionFieldName = (Model.Name "namespace")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        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.pegasus.pdl.SchemaFile"),
              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.pegasus.pdl.SchemaFile"),
              Model.projectionFieldName = (Model.Name "imports")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schemas"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the fixed variant of hydra.ext.pegasus.pdl.Schema
schemaFixed :: Typed.TypedTerm Int -> Typed.TypedTerm Pdl.Schema
schemaFixed x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.Schema"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "fixed"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the inline variant of hydra.ext.pegasus.pdl.Schema
schemaInline :: Typed.TypedTerm Pdl.NamedSchema -> Typed.TypedTerm Pdl.Schema
schemaInline x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.Schema"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "inline"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

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

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

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

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

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

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

-- | DSL accessor for the body of hydra.ext.pegasus.pdl.EnumFieldName
unEnumFieldName :: Typed.TypedTerm Pdl.EnumFieldName -> Typed.TypedTerm String
unEnumFieldName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.pegasus.pdl.EnumFieldName")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

-- | DSL accessor for the body of hydra.ext.pegasus.pdl.Name
unName :: Typed.TypedTerm Pdl.Name -> Typed.TypedTerm String
unName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.pegasus.pdl.Name")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.pegasus.pdl.Namespace
unNamespace :: Typed.TypedTerm Pdl.Namespace -> Typed.TypedTerm String
unNamespace x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.pegasus.pdl.Namespace")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.pegasus.pdl.Package
unPackage :: Typed.TypedTerm Pdl.Package -> Typed.TypedTerm String
unPackage x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.pegasus.pdl.Package")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.pegasus.pdl.PropertyKey
unPropertyKey :: Typed.TypedTerm Pdl.PropertyKey -> Typed.TypedTerm String
unPropertyKey x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.pegasus.pdl.PropertyKey")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.pegasus.pdl.UnionSchema
unUnionSchema :: Typed.TypedTerm Pdl.UnionSchema -> Typed.TypedTerm [Pdl.UnionMember]
unUnionSchema x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.pegasus.pdl.UnionSchema")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL constructor for hydra.ext.pegasus.pdl.UnionMember
unionMember :: Typed.TypedTerm (Maybe Pdl.FieldName) -> Typed.TypedTerm Pdl.Schema -> Typed.TypedTerm Pdl.Annotations -> Typed.TypedTerm Pdl.UnionMember
unionMember alias value annotations =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.UnionMember"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "alias"),
          Model.fieldTerm = (Typed.unTypedTerm alias)},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          Model.fieldTerm = (Typed.unTypedTerm value)},
        Model.Field {
          Model.fieldName = (Model.Name "annotations"),
          Model.fieldTerm = (Typed.unTypedTerm annotations)}]}))

-- | DSL accessor for the alias field of hydra.ext.pegasus.pdl.UnionMember
unionMemberAlias :: Typed.TypedTerm Pdl.UnionMember -> Typed.TypedTerm (Maybe Pdl.FieldName)
unionMemberAlias x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.UnionMember"),
        Model.projectionFieldName = (Model.Name "alias")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the annotations field of hydra.ext.pegasus.pdl.UnionMember
unionMemberAnnotations :: Typed.TypedTerm Pdl.UnionMember -> Typed.TypedTerm Pdl.Annotations
unionMemberAnnotations x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.UnionMember"),
        Model.projectionFieldName = (Model.Name "annotations")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.pegasus.pdl.UnionMember
unionMemberUnionMember :: Typed.TypedName Pdl.UnionMember
unionMemberUnionMember = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.UnionMember")

-- | DSL accessor for the value field of hydra.ext.pegasus.pdl.UnionMember
unionMemberValue :: Typed.TypedTerm Pdl.UnionMember -> Typed.TypedTerm Pdl.Schema
unionMemberValue x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.UnionMember"),
        Model.projectionFieldName = (Model.Name "value")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the alias field of hydra.ext.pegasus.pdl.UnionMember
unionMemberWithAlias :: Typed.TypedTerm Pdl.UnionMember -> Typed.TypedTerm (Maybe Pdl.FieldName) -> Typed.TypedTerm Pdl.UnionMember
unionMemberWithAlias original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.UnionMember"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "alias"),
          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.pegasus.pdl.UnionMember"),
              Model.projectionFieldName = (Model.Name "value")})),
            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.pegasus.pdl.UnionMember"),
              Model.projectionFieldName = (Model.Name "annotations")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the annotations field of hydra.ext.pegasus.pdl.UnionMember
unionMemberWithAnnotations :: Typed.TypedTerm Pdl.UnionMember -> Typed.TypedTerm Pdl.Annotations -> Typed.TypedTerm Pdl.UnionMember
unionMemberWithAnnotations original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.UnionMember"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "alias"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.UnionMember"),
              Model.projectionFieldName = (Model.Name "alias")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        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.pegasus.pdl.UnionMember"),
              Model.projectionFieldName = (Model.Name "value")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "annotations"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the value field of hydra.ext.pegasus.pdl.UnionMember
unionMemberWithValue :: Typed.TypedTerm Pdl.UnionMember -> Typed.TypedTerm Pdl.Schema -> Typed.TypedTerm Pdl.UnionMember
unionMemberWithValue original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.pegasus.pdl.UnionMember"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "alias"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.pegasus.pdl.UnionMember"),
              Model.projectionFieldName = (Model.Name "alias")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "value"),
          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.pegasus.pdl.UnionMember"),
              Model.projectionFieldName = (Model.Name "annotations")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for the hydra.ext.pegasus.pdl.UnionSchema wrapper
unionSchema :: Typed.TypedTerm [Pdl.UnionMember] -> Typed.TypedTerm Pdl.UnionSchema
unionSchema x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.pegasus.pdl.UnionSchema"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.pegasus.pdl.UnionSchema
unionSchemaUnionSchema :: Typed.TypedName Pdl.UnionSchema
unionSchemaUnionSchema = Typed.TypedName (Model.Name "hydra.ext.pegasus.pdl.UnionSchema")