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

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

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

module Hydra.Ext.Dsl.Osv.Schema where

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

-- | DSL constructor for hydra.ext.osv.schema.Credited
credited :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe [Schema.Url]) -> Typed.TypedTerm Schema.Credited
credited name contact =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Credited"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "contact"),
          Model.fieldTerm = (Typed.unTypedTerm contact)}]}))

-- | DSL accessor for the contact field of hydra.ext.osv.schema.Credited
creditedContact :: Typed.TypedTerm Schema.Credited -> Typed.TypedTerm (Maybe [Schema.Url])
creditedContact x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Credited"),
        Model.projectionFieldName = (Model.Name "contact")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

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

-- | DSL updater for the contact field of hydra.ext.osv.schema.Credited
creditedWithContact :: Typed.TypedTerm Schema.Credited -> Typed.TypedTerm (Maybe [Schema.Url]) -> Typed.TypedTerm Schema.Credited
creditedWithContact original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Credited"),
      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.osv.schema.Credited"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "contact"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

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

-- | DSL constructor for the hydra.ext.osv.schema.Ecosystem wrapper
ecosystem :: Typed.TypedTerm String -> Typed.TypedTerm Schema.Ecosystem
ecosystem x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.osv.schema.Ecosystem"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

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

-- | DSL constructor for hydra.ext.osv.schema.Entry
entry :: Typed.TypedTerm (Maybe Schema.OsvVersion) -> Typed.TypedTerm Schema.Id -> Typed.TypedTerm Schema.Timestamp -> Typed.TypedTerm (Maybe Schema.Timestamp) -> Typed.TypedTerm (Maybe Schema.Timestamp) -> Typed.TypedTerm (Maybe [Schema.Id]) -> Typed.TypedTerm (Maybe [Schema.Id]) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe Schema.Markdown) -> Typed.TypedTerm (Maybe [Schema.Severity]) -> Typed.TypedTerm (Maybe [Schema.PackageVersions]) -> Typed.TypedTerm (Maybe [Schema.Reference]) -> Typed.TypedTerm (Maybe [Schema.Credited]) -> Typed.TypedTerm Schema.Entry
entry schemaVersion id modified published withdrawn aliases related summary details severity affected references credits =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "schemaVersion"),
          Model.fieldTerm = (Typed.unTypedTerm schemaVersion)},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm id)},
        Model.Field {
          Model.fieldName = (Model.Name "modified"),
          Model.fieldTerm = (Typed.unTypedTerm modified)},
        Model.Field {
          Model.fieldName = (Model.Name "published"),
          Model.fieldTerm = (Typed.unTypedTerm published)},
        Model.Field {
          Model.fieldName = (Model.Name "withdrawn"),
          Model.fieldTerm = (Typed.unTypedTerm withdrawn)},
        Model.Field {
          Model.fieldName = (Model.Name "aliases"),
          Model.fieldTerm = (Typed.unTypedTerm aliases)},
        Model.Field {
          Model.fieldName = (Model.Name "related"),
          Model.fieldTerm = (Typed.unTypedTerm related)},
        Model.Field {
          Model.fieldName = (Model.Name "summary"),
          Model.fieldTerm = (Typed.unTypedTerm summary)},
        Model.Field {
          Model.fieldName = (Model.Name "details"),
          Model.fieldTerm = (Typed.unTypedTerm details)},
        Model.Field {
          Model.fieldName = (Model.Name "severity"),
          Model.fieldTerm = (Typed.unTypedTerm severity)},
        Model.Field {
          Model.fieldName = (Model.Name "affected"),
          Model.fieldTerm = (Typed.unTypedTerm affected)},
        Model.Field {
          Model.fieldName = (Model.Name "references"),
          Model.fieldTerm = (Typed.unTypedTerm references)},
        Model.Field {
          Model.fieldName = (Model.Name "credits"),
          Model.fieldTerm = (Typed.unTypedTerm credits)}]}))

-- | DSL accessor for the affected field of hydra.ext.osv.schema.Entry
entryAffected :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe [Schema.PackageVersions])
entryAffected x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
        Model.projectionFieldName = (Model.Name "affected")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

-- | DSL accessor for the credits field of hydra.ext.osv.schema.Entry
entryCredits :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe [Schema.Credited])
entryCredits x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
        Model.projectionFieldName = (Model.Name "credits")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the details field of hydra.ext.osv.schema.Entry
entryDetails :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe Schema.Markdown)
entryDetails x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
        Model.projectionFieldName = (Model.Name "details")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

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

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

-- | DSL accessor for the published field of hydra.ext.osv.schema.Entry
entryPublished :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe Schema.Timestamp)
entryPublished x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
        Model.projectionFieldName = (Model.Name "published")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the references field of hydra.ext.osv.schema.Entry
entryReferences :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe [Schema.Reference])
entryReferences x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
        Model.projectionFieldName = (Model.Name "references")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the related field of hydra.ext.osv.schema.Entry
entryRelated :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe [Schema.Id])
entryRelated x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
        Model.projectionFieldName = (Model.Name "related")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the schemaVersion field of hydra.ext.osv.schema.Entry
entrySchemaVersion :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe Schema.OsvVersion)
entrySchemaVersion x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
        Model.projectionFieldName = (Model.Name "schemaVersion")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the severity field of hydra.ext.osv.schema.Entry
entrySeverity :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe [Schema.Severity])
entrySeverity x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
        Model.projectionFieldName = (Model.Name "severity")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

-- | DSL updater for the affected field of hydra.ext.osv.schema.Entry
entryWithAffected :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe [Schema.PackageVersions]) -> Typed.TypedTerm Schema.Entry
entryWithAffected original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "schemaVersion"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "schemaVersion")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modified"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "modified")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "published"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "published")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "withdrawn"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "withdrawn")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "aliases"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "aliases")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "related"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "related")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "summary"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "summary")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "details"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "details")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "severity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "severity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "affected"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "references"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "references")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "credits"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "credits")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the aliases field of hydra.ext.osv.schema.Entry
entryWithAliases :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe [Schema.Id]) -> Typed.TypedTerm Schema.Entry
entryWithAliases original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "schemaVersion"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "schemaVersion")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modified"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "modified")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "published"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "published")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "withdrawn"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "withdrawn")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "aliases"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "related"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "related")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "summary"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "summary")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "details"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "details")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "severity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "severity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "affected"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "affected")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "references"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "references")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "credits"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "credits")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the credits field of hydra.ext.osv.schema.Entry
entryWithCredits :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe [Schema.Credited]) -> Typed.TypedTerm Schema.Entry
entryWithCredits original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "schemaVersion"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "schemaVersion")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modified"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "modified")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "published"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "published")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "withdrawn"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "withdrawn")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "aliases"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "aliases")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "related"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "related")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "summary"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "summary")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "details"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "details")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "severity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "severity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "affected"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "affected")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "references"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "references")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "credits"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the details field of hydra.ext.osv.schema.Entry
entryWithDetails :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe Schema.Markdown) -> Typed.TypedTerm Schema.Entry
entryWithDetails original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "schemaVersion"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "schemaVersion")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modified"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "modified")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "published"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "published")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "withdrawn"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "withdrawn")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "aliases"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "aliases")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "related"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "related")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "summary"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "summary")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "details"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "severity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "severity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "affected"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "affected")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "references"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "references")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "credits"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "credits")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the id field of hydra.ext.osv.schema.Entry
entryWithId :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm Schema.Id -> Typed.TypedTerm Schema.Entry
entryWithId original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "schemaVersion"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "schemaVersion")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "modified"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "modified")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "published"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "published")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "withdrawn"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "withdrawn")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "aliases"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "aliases")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "related"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "related")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "summary"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "summary")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "details"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "details")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "severity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "severity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "affected"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "affected")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "references"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "references")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "credits"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "credits")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the modified field of hydra.ext.osv.schema.Entry
entryWithModified :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm Schema.Timestamp -> Typed.TypedTerm Schema.Entry
entryWithModified original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "schemaVersion"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "schemaVersion")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modified"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "published"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "published")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "withdrawn"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "withdrawn")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "aliases"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "aliases")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "related"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "related")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "summary"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "summary")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "details"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "details")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "severity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "severity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "affected"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "affected")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "references"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "references")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "credits"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "credits")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the published field of hydra.ext.osv.schema.Entry
entryWithPublished :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe Schema.Timestamp) -> Typed.TypedTerm Schema.Entry
entryWithPublished original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "schemaVersion"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "schemaVersion")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modified"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "modified")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "published"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "withdrawn"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "withdrawn")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "aliases"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "aliases")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "related"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "related")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "summary"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "summary")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "details"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "details")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "severity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "severity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "affected"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "affected")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "references"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "references")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "credits"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "credits")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the references field of hydra.ext.osv.schema.Entry
entryWithReferences :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe [Schema.Reference]) -> Typed.TypedTerm Schema.Entry
entryWithReferences original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "schemaVersion"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "schemaVersion")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modified"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "modified")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "published"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "published")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "withdrawn"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "withdrawn")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "aliases"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "aliases")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "related"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "related")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "summary"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "summary")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "details"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "details")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "severity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "severity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "affected"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "affected")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "references"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "credits"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "credits")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the related field of hydra.ext.osv.schema.Entry
entryWithRelated :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe [Schema.Id]) -> Typed.TypedTerm Schema.Entry
entryWithRelated original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "schemaVersion"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "schemaVersion")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modified"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "modified")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "published"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "published")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "withdrawn"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "withdrawn")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "aliases"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "aliases")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "related"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "summary"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "summary")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "details"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "details")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "severity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "severity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "affected"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "affected")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "references"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "references")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "credits"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "credits")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the schemaVersion field of hydra.ext.osv.schema.Entry
entryWithSchemaVersion :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe Schema.OsvVersion) -> Typed.TypedTerm Schema.Entry
entryWithSchemaVersion original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "schemaVersion"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modified"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "modified")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "published"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "published")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "withdrawn"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "withdrawn")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "aliases"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "aliases")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "related"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "related")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "summary"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "summary")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "details"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "details")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "severity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "severity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "affected"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "affected")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "references"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "references")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "credits"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "credits")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the severity field of hydra.ext.osv.schema.Entry
entryWithSeverity :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe [Schema.Severity]) -> Typed.TypedTerm Schema.Entry
entryWithSeverity original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "schemaVersion"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "schemaVersion")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modified"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "modified")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "published"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "published")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "withdrawn"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "withdrawn")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "aliases"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "aliases")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "related"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "related")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "summary"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "summary")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "details"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "details")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "severity"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "affected"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "affected")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "references"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "references")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "credits"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "credits")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the summary field of hydra.ext.osv.schema.Entry
entryWithSummary :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Schema.Entry
entryWithSummary original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "schemaVersion"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "schemaVersion")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modified"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "modified")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "published"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "published")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "withdrawn"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "withdrawn")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "aliases"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "aliases")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "related"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "related")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "summary"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "details"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "details")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "severity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "severity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "affected"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "affected")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "references"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "references")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "credits"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "credits")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the withdrawn field of hydra.ext.osv.schema.Entry
entryWithWithdrawn :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe Schema.Timestamp) -> Typed.TypedTerm Schema.Entry
entryWithWithdrawn original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "schemaVersion"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "schemaVersion")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "modified"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "modified")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "published"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "published")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "withdrawn"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "aliases"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "aliases")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "related"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "related")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "summary"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "summary")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "details"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "details")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "severity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "severity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "affected"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "affected")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "references"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "references")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "credits"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
              Model.projectionFieldName = (Model.Name "credits")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL accessor for the withdrawn field of hydra.ext.osv.schema.Entry
entryWithdrawn :: Typed.TypedTerm Schema.Entry -> Typed.TypedTerm (Maybe Schema.Timestamp)
entryWithdrawn x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Entry"),
        Model.projectionFieldName = (Model.Name "withdrawn")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

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

-- | DSL injection for the introduced variant of hydra.ext.osv.schema.Event
eventIntroduced :: Typed.TypedTerm Schema.VersionOrZero -> Typed.TypedTerm Schema.Event
eventIntroduced x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.osv.schema.Event"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "introduced"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the lastAffected variant of hydra.ext.osv.schema.Event
eventLastAffected :: Typed.TypedTerm Schema.Version -> Typed.TypedTerm Schema.Event
eventLastAffected x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.osv.schema.Event"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "lastAffected"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the limit variant of hydra.ext.osv.schema.Event
eventLimit :: Typed.TypedTerm Schema.VersionOrStar -> Typed.TypedTerm Schema.Event
eventLimit x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.osv.schema.Event"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "limit"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for the hydra.ext.osv.schema.Id wrapper
id :: Typed.TypedTerm String -> Typed.TypedTerm Schema.Id
id x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.osv.schema.Id"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

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

-- | DSL constructor for the hydra.ext.osv.schema.Markdown wrapper
markdown :: Typed.TypedTerm String -> Typed.TypedTerm Schema.Markdown
markdown x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.osv.schema.Markdown"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

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

-- | DSL constructor for the hydra.ext.osv.schema.OsvVersion wrapper
osvVersion :: Typed.TypedTerm String -> Typed.TypedTerm Schema.OsvVersion
osvVersion x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.osv.schema.OsvVersion"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

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

-- | DSL constructor for hydra.ext.osv.schema.Package
package :: Typed.TypedTerm Schema.Ecosystem -> Typed.TypedTerm String -> Typed.TypedTerm (Maybe Schema.Url) -> Typed.TypedTerm Schema.Package
package ecosystem name purl =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Package"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "ecosystem"),
          Model.fieldTerm = (Typed.unTypedTerm ecosystem)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "purl"),
          Model.fieldTerm = (Typed.unTypedTerm purl)}]}))

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

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

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

-- | DSL accessor for the purl field of hydra.ext.osv.schema.Package
packagePurl :: Typed.TypedTerm Schema.Package -> Typed.TypedTerm (Maybe Schema.Url)
packagePurl x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Package"),
        Model.projectionFieldName = (Model.Name "purl")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL constructor for hydra.ext.osv.schema.PackageVersions
packageVersions :: Typed.TypedTerm Schema.Package -> Typed.TypedTerm (Maybe [Schema.VersionRange]) -> Typed.TypedTerm (Maybe [Schema.Version]) -> Typed.TypedTerm Schema.PackageVersions
packageVersions package ranges versions =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.PackageVersions"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "package"),
          Model.fieldTerm = (Typed.unTypedTerm package)},
        Model.Field {
          Model.fieldName = (Model.Name "ranges"),
          Model.fieldTerm = (Typed.unTypedTerm ranges)},
        Model.Field {
          Model.fieldName = (Model.Name "versions"),
          Model.fieldTerm = (Typed.unTypedTerm versions)}]}))

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

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

-- | DSL accessor for the ranges field of hydra.ext.osv.schema.PackageVersions
packageVersionsRanges :: Typed.TypedTerm Schema.PackageVersions -> Typed.TypedTerm (Maybe [Schema.VersionRange])
packageVersionsRanges x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.PackageVersions"),
        Model.projectionFieldName = (Model.Name "ranges")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the versions field of hydra.ext.osv.schema.PackageVersions
packageVersionsVersions :: Typed.TypedTerm Schema.PackageVersions -> Typed.TypedTerm (Maybe [Schema.Version])
packageVersionsVersions x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.PackageVersions"),
        Model.projectionFieldName = (Model.Name "versions")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the package field of hydra.ext.osv.schema.PackageVersions
packageVersionsWithPackage :: Typed.TypedTerm Schema.PackageVersions -> Typed.TypedTerm Schema.Package -> Typed.TypedTerm Schema.PackageVersions
packageVersionsWithPackage original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.PackageVersions"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "package"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "ranges"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.PackageVersions"),
              Model.projectionFieldName = (Model.Name "ranges")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "versions"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.PackageVersions"),
              Model.projectionFieldName = (Model.Name "versions")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the ranges field of hydra.ext.osv.schema.PackageVersions
packageVersionsWithRanges :: Typed.TypedTerm Schema.PackageVersions -> Typed.TypedTerm (Maybe [Schema.VersionRange]) -> Typed.TypedTerm Schema.PackageVersions
packageVersionsWithRanges original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.PackageVersions"),
      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.osv.schema.PackageVersions"),
              Model.projectionFieldName = (Model.Name "package")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "ranges"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "versions"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.PackageVersions"),
              Model.projectionFieldName = (Model.Name "versions")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the versions field of hydra.ext.osv.schema.PackageVersions
packageVersionsWithVersions :: Typed.TypedTerm Schema.PackageVersions -> Typed.TypedTerm (Maybe [Schema.Version]) -> Typed.TypedTerm Schema.PackageVersions
packageVersionsWithVersions original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.PackageVersions"),
      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.osv.schema.PackageVersions"),
              Model.projectionFieldName = (Model.Name "package")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "ranges"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.PackageVersions"),
              Model.projectionFieldName = (Model.Name "ranges")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "versions"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the ecosystem field of hydra.ext.osv.schema.Package
packageWithEcosystem :: Typed.TypedTerm Schema.Package -> Typed.TypedTerm Schema.Ecosystem -> Typed.TypedTerm Schema.Package
packageWithEcosystem original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Package"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "ecosystem"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        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.osv.schema.Package"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "purl"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Package"),
              Model.projectionFieldName = (Model.Name "purl")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

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

-- | DSL updater for the purl field of hydra.ext.osv.schema.Package
packageWithPurl :: Typed.TypedTerm Schema.Package -> Typed.TypedTerm (Maybe Schema.Url) -> Typed.TypedTerm Schema.Package
packageWithPurl original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Package"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "ecosystem"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.Package"),
              Model.projectionFieldName = (Model.Name "ecosystem")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        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.osv.schema.Package"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "purl"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.osv.schema.Reference
reference :: Typed.TypedTerm Schema.ReferenceType -> Typed.TypedTerm Schema.Url -> Typed.TypedTerm Schema.Reference
reference type_ url =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Reference"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "url"),
          Model.fieldTerm = (Typed.unTypedTerm url)}]}))

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

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

-- | DSL constructor for the hydra.ext.osv.schema.ReferenceType wrapper
referenceType2 :: Typed.TypedTerm String -> Typed.TypedTerm Schema.ReferenceType
referenceType2 x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.osv.schema.ReferenceType"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

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

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

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

-- | DSL updater for the url field of hydra.ext.osv.schema.Reference
referenceWithUrl :: Typed.TypedTerm Schema.Reference -> Typed.TypedTerm Schema.Url -> Typed.TypedTerm Schema.Reference
referenceWithUrl original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Reference"),
      Model.recordFields = [
        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.osv.schema.Reference"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "url"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.ext.osv.schema.Severity
severity :: Typed.TypedTerm Schema.SeverityType -> Typed.TypedTerm Schema.SeverityScore -> Typed.TypedTerm Schema.Severity
severity type_ score =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Severity"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "score"),
          Model.fieldTerm = (Typed.unTypedTerm score)}]}))

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

-- | DSL constructor for the hydra.ext.osv.schema.SeverityScore wrapper
severityScore2 :: Typed.TypedTerm String -> Typed.TypedTerm Schema.SeverityScore
severityScore2 x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.osv.schema.SeverityScore"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

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

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

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

-- | DSL constructor for the hydra.ext.osv.schema.SeverityType wrapper
severityType2 :: Typed.TypedTerm String -> Typed.TypedTerm Schema.SeverityType
severityType2 x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.osv.schema.SeverityType"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

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

-- | DSL updater for the score field of hydra.ext.osv.schema.Severity
severityWithScore :: Typed.TypedTerm Schema.Severity -> Typed.TypedTerm Schema.SeverityScore -> Typed.TypedTerm Schema.Severity
severityWithScore original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.Severity"),
      Model.recordFields = [
        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.osv.schema.Severity"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "score"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

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

-- | DSL constructor for the hydra.ext.osv.schema.Timestamp wrapper
timestamp :: Typed.TypedTerm String -> Typed.TypedTerm Schema.Timestamp
timestamp x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.osv.schema.Timestamp"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

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

-- | DSL accessor for the body of hydra.ext.osv.schema.Ecosystem
unEcosystem :: Typed.TypedTerm Schema.Ecosystem -> Typed.TypedTerm String
unEcosystem x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.osv.schema.Ecosystem")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.osv.schema.Id
unId :: Typed.TypedTerm Schema.Id -> Typed.TypedTerm String
unId x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.osv.schema.Id")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.osv.schema.Markdown
unMarkdown :: Typed.TypedTerm Schema.Markdown -> Typed.TypedTerm String
unMarkdown x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.osv.schema.Markdown")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.osv.schema.OsvVersion
unOsvVersion :: Typed.TypedTerm Schema.OsvVersion -> Typed.TypedTerm String
unOsvVersion x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.osv.schema.OsvVersion")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.osv.schema.ReferenceType
unReferenceType :: Typed.TypedTerm Schema.ReferenceType -> Typed.TypedTerm String
unReferenceType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.osv.schema.ReferenceType")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.osv.schema.SeverityScore
unSeverityScore :: Typed.TypedTerm Schema.SeverityScore -> Typed.TypedTerm String
unSeverityScore x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.osv.schema.SeverityScore")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.osv.schema.SeverityType
unSeverityType :: Typed.TypedTerm Schema.SeverityType -> Typed.TypedTerm String
unSeverityType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.osv.schema.SeverityType")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.osv.schema.Timestamp
unTimestamp :: Typed.TypedTerm Schema.Timestamp -> Typed.TypedTerm String
unTimestamp x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.osv.schema.Timestamp")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.osv.schema.Url
unUrl :: Typed.TypedTerm Schema.Url -> Typed.TypedTerm String
unUrl x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.osv.schema.Url")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.osv.schema.Version
unVersion :: Typed.TypedTerm Schema.Version -> Typed.TypedTerm String
unVersion x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.osv.schema.Version")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.osv.schema.VersionOrStar
unVersionOrStar :: Typed.TypedTerm Schema.VersionOrStar -> Typed.TypedTerm String
unVersionOrStar x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.osv.schema.VersionOrStar")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.osv.schema.VersionOrZero
unVersionOrZero :: Typed.TypedTerm Schema.VersionOrZero -> Typed.TypedTerm String
unVersionOrZero x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.osv.schema.VersionOrZero")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.osv.schema.VersionType
unVersionType :: Typed.TypedTerm Schema.VersionType -> Typed.TypedTerm String
unVersionType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.osv.schema.VersionType")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL constructor for the hydra.ext.osv.schema.Url wrapper
url :: Typed.TypedTerm String -> Typed.TypedTerm Schema.Url
url x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.osv.schema.Url"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

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

-- | DSL constructor for the hydra.ext.osv.schema.Version wrapper
version :: Typed.TypedTerm String -> Typed.TypedTerm Schema.Version
version x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.osv.schema.Version"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL constructor for the hydra.ext.osv.schema.VersionOrStar wrapper
versionOrStar :: Typed.TypedTerm String -> Typed.TypedTerm Schema.VersionOrStar
versionOrStar x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.osv.schema.VersionOrStar"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

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

-- | DSL constructor for the hydra.ext.osv.schema.VersionOrZero wrapper
versionOrZero :: Typed.TypedTerm String -> Typed.TypedTerm Schema.VersionOrZero
versionOrZero x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.osv.schema.VersionOrZero"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

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

-- | DSL constructor for hydra.ext.osv.schema.VersionRange
versionRange :: Typed.TypedTerm Schema.VersionType -> Typed.TypedTerm (Maybe Schema.Url) -> Typed.TypedTerm [Schema.Event] -> Typed.TypedTerm Schema.VersionRange
versionRange type_ repo events =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.VersionRange"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "repo"),
          Model.fieldTerm = (Typed.unTypedTerm repo)},
        Model.Field {
          Model.fieldName = (Model.Name "events"),
          Model.fieldTerm = (Typed.unTypedTerm events)}]}))

-- | DSL accessor for the events field of hydra.ext.osv.schema.VersionRange
versionRangeEvents :: Typed.TypedTerm Schema.VersionRange -> Typed.TypedTerm [Schema.Event]
versionRangeEvents x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.VersionRange"),
        Model.projectionFieldName = (Model.Name "events")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the repo field of hydra.ext.osv.schema.VersionRange
versionRangeRepo :: Typed.TypedTerm Schema.VersionRange -> Typed.TypedTerm (Maybe Schema.Url)
versionRangeRepo x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.VersionRange"),
        Model.projectionFieldName = (Model.Name "repo")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

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

-- | DSL updater for the events field of hydra.ext.osv.schema.VersionRange
versionRangeWithEvents :: Typed.TypedTerm Schema.VersionRange -> Typed.TypedTerm [Schema.Event] -> Typed.TypedTerm Schema.VersionRange
versionRangeWithEvents original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.VersionRange"),
      Model.recordFields = [
        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.osv.schema.VersionRange"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "repo"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.VersionRange"),
              Model.projectionFieldName = (Model.Name "repo")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "events"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the repo field of hydra.ext.osv.schema.VersionRange
versionRangeWithRepo :: Typed.TypedTerm Schema.VersionRange -> Typed.TypedTerm (Maybe Schema.Url) -> Typed.TypedTerm Schema.VersionRange
versionRangeWithRepo original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.VersionRange"),
      Model.recordFields = [
        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.osv.schema.VersionRange"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "repo"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "events"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.VersionRange"),
              Model.projectionFieldName = (Model.Name "events")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.osv.schema.VersionRange
versionRangeWithType :: Typed.TypedTerm Schema.VersionRange -> Typed.TypedTerm Schema.VersionType -> Typed.TypedTerm Schema.VersionRange
versionRangeWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.osv.schema.VersionRange"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "repo"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.VersionRange"),
              Model.projectionFieldName = (Model.Name "repo")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "events"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.osv.schema.VersionRange"),
              Model.projectionFieldName = (Model.Name "events")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for the hydra.ext.osv.schema.VersionType wrapper
versionType :: Typed.TypedTerm String -> Typed.TypedTerm Schema.VersionType
versionType x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.osv.schema.VersionType"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

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

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