hydra-ext-0.18.0: src/main/haskell/Hydra/Ext/Dsl/Azure/Dtld.hs

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

-- | DSL functions for hydra.ext.azure.dtld

module Hydra.Ext.Dsl.Azure.Dtld where

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

-- | DSL constructor for hydra.ext.azure.dtld.Command
command :: Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm String -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe Dtld.CommandType) -> Typed.TypedTerm (Maybe Dtld.CommandPayload) -> Typed.TypedTerm (Maybe Dtld.CommandPayload) -> Typed.TypedTerm Dtld.Command
command type_ name id comment description displayName commandType request response =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm id)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm comment)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm description)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm displayName)},
        Model.Field {
          Model.fieldName = (Model.Name "commandType"),
          Model.fieldTerm = (Typed.unTypedTerm commandType)},
        Model.Field {
          Model.fieldName = (Model.Name "request"),
          Model.fieldTerm = (Typed.unTypedTerm request)},
        Model.Field {
          Model.fieldName = (Model.Name "response"),
          Model.fieldTerm = (Typed.unTypedTerm response)}]}))

-- | DSL name token for hydra.ext.azure.dtld.Command
commandCommand :: Typed.TypedName Dtld.Command
commandCommand = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.Command")

-- | DSL accessor for the commandType field of hydra.ext.azure.dtld.Command
commandCommandType :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm (Maybe Dtld.CommandType)
commandCommandType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
        Model.projectionFieldName = (Model.Name "commandType")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the comment field of hydra.ext.azure.dtld.Command
commandComment :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm (Maybe String)
commandComment x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
        Model.projectionFieldName = (Model.Name "comment")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the description field of hydra.ext.azure.dtld.Command
commandDescription :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm (Maybe String)
commandDescription x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
        Model.projectionFieldName = (Model.Name "description")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.Command
commandDisplayName :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm (Maybe String)
commandDisplayName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
        Model.projectionFieldName = (Model.Name "displayName")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the id field of hydra.ext.azure.dtld.Command
commandId :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm (Maybe Dtld.Dtmi)
commandId x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
        Model.projectionFieldName = (Model.Name "id")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the name field of hydra.ext.azure.dtld.Command
commandName :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm String
commandName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL constructor for hydra.ext.azure.dtld.CommandPayload
commandPayload :: Typed.TypedTerm String -> Typed.TypedTerm Dtld.Schema -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.CommandPayload
commandPayload name schema id comment description displayName =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Typed.unTypedTerm schema)},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm id)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm comment)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm description)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm displayName)}]}))

-- | DSL name token for hydra.ext.azure.dtld.CommandPayload
commandPayloadCommandPayload :: Typed.TypedName Dtld.CommandPayload
commandPayloadCommandPayload = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.CommandPayload")

-- | DSL accessor for the comment field of hydra.ext.azure.dtld.CommandPayload
commandPayloadComment :: Typed.TypedTerm Dtld.CommandPayload -> Typed.TypedTerm (Maybe String)
commandPayloadComment x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
        Model.projectionFieldName = (Model.Name "comment")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the description field of hydra.ext.azure.dtld.CommandPayload
commandPayloadDescription :: Typed.TypedTerm Dtld.CommandPayload -> Typed.TypedTerm (Maybe String)
commandPayloadDescription x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
        Model.projectionFieldName = (Model.Name "description")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.CommandPayload
commandPayloadDisplayName :: Typed.TypedTerm Dtld.CommandPayload -> Typed.TypedTerm (Maybe String)
commandPayloadDisplayName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
        Model.projectionFieldName = (Model.Name "displayName")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the id field of hydra.ext.azure.dtld.CommandPayload
commandPayloadId :: Typed.TypedTerm Dtld.CommandPayload -> Typed.TypedTerm (Maybe Dtld.Dtmi)
commandPayloadId x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
        Model.projectionFieldName = (Model.Name "id")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the name field of hydra.ext.azure.dtld.CommandPayload
commandPayloadName :: Typed.TypedTerm Dtld.CommandPayload -> Typed.TypedTerm String
commandPayloadName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

-- | DSL updater for the comment field of hydra.ext.azure.dtld.CommandPayload
commandPayloadWithComment :: Typed.TypedTerm Dtld.CommandPayload -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.CommandPayload
commandPayloadWithComment original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
      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.azure.dtld.CommandPayload"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.CommandPayload"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the description field of hydra.ext.azure.dtld.CommandPayload
commandPayloadWithDescription :: Typed.TypedTerm Dtld.CommandPayload -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.CommandPayload
commandPayloadWithDescription original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
      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.azure.dtld.CommandPayload"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.CommandPayload"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the displayName field of hydra.ext.azure.dtld.CommandPayload
commandPayloadWithDisplayName :: Typed.TypedTerm Dtld.CommandPayload -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.CommandPayload
commandPayloadWithDisplayName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
      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.azure.dtld.CommandPayload"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.CommandPayload"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the id field of hydra.ext.azure.dtld.CommandPayload
commandPayloadWithId :: Typed.TypedTerm Dtld.CommandPayload -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm Dtld.CommandPayload
commandPayloadWithId original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
      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.azure.dtld.CommandPayload"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.azure.dtld.CommandPayload
commandPayloadWithName :: Typed.TypedTerm Dtld.CommandPayload -> Typed.TypedTerm String -> Typed.TypedTerm Dtld.CommandPayload
commandPayloadWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.CommandPayload"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the schema field of hydra.ext.azure.dtld.CommandPayload
commandPayloadWithSchema :: Typed.TypedTerm Dtld.CommandPayload -> Typed.TypedTerm Dtld.Schema -> Typed.TypedTerm Dtld.CommandPayload
commandPayloadWithSchema original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
      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.azure.dtld.CommandPayload"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          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.azure.dtld.CommandPayload"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandPayload"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL accessor for the request field of hydra.ext.azure.dtld.Command
commandRequest :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm (Maybe Dtld.CommandPayload)
commandRequest x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
        Model.projectionFieldName = (Model.Name "request")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the response field of hydra.ext.azure.dtld.Command
commandResponse :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm (Maybe Dtld.CommandPayload)
commandResponse x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
        Model.projectionFieldName = (Model.Name "response")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.azure.dtld.Command
commandType :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm Dtld.Iri
commandType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL injection for the asynchronous variant of hydra.ext.azure.dtld.CommandType
commandTypeAsynchronous :: Typed.TypedTerm Dtld.CommandType
commandTypeAsynchronous =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "asynchronous"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.azure.dtld.CommandType
commandTypeCommandType :: Typed.TypedName Dtld.CommandType
commandTypeCommandType = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.CommandType")

-- | DSL injection for the synchronous variant of hydra.ext.azure.dtld.CommandType
commandTypeSynchronous :: Typed.TypedTerm Dtld.CommandType
commandTypeSynchronous =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.CommandType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "synchronous"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL updater for the commandType field of hydra.ext.azure.dtld.Command
commandWithCommandType :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm (Maybe Dtld.CommandType) -> Typed.TypedTerm Dtld.Command
commandWithCommandType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
      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.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "name")})),
            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.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "commandType"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "request"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "request")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "response"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "response")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the comment field of hydra.ext.azure.dtld.Command
commandWithComment :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Command
commandWithComment original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
      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.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "name")})),
            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.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "commandType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "commandType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "request"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "request")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "response"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "response")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the description field of hydra.ext.azure.dtld.Command
commandWithDescription :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Command
commandWithDescription original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
      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.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "name")})),
            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.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "commandType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "commandType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "request"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "request")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "response"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "response")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the displayName field of hydra.ext.azure.dtld.Command
commandWithDisplayName :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Command
commandWithDisplayName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
      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.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "name")})),
            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.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "commandType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "commandType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "request"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "request")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "response"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "response")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the id field of hydra.ext.azure.dtld.Command
commandWithId :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm Dtld.Command
commandWithId original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
      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.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "commandType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "commandType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "request"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "request")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "response"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "response")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.azure.dtld.Command
commandWithName :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm String -> Typed.TypedTerm Dtld.Command
commandWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
      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.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          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.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "commandType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "commandType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "request"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "request")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "response"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "response")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the request field of hydra.ext.azure.dtld.Command
commandWithRequest :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm (Maybe Dtld.CommandPayload) -> Typed.TypedTerm Dtld.Command
commandWithRequest original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
      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.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "name")})),
            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.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "commandType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "commandType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "request"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "response"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "response")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the response field of hydra.ext.azure.dtld.Command
commandWithResponse :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm (Maybe Dtld.CommandPayload) -> Typed.TypedTerm Dtld.Command
commandWithResponse original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
      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.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "name")})),
            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.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "commandType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "commandType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "request"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "request")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "response"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the type field of hydra.ext.azure.dtld.Command
commandWithType :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm Dtld.Command
commandWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          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.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "name")})),
            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.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "commandType"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "commandType")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "request"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "request")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "response"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Command"),
              Model.projectionFieldName = (Model.Name "response")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.azure.dtld.Component
component :: Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm String -> Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Component
component type_ name schema id comment description displayName =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Typed.unTypedTerm schema)},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm id)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm comment)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm description)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm displayName)}]}))

-- | DSL accessor for the comment field of hydra.ext.azure.dtld.Component
componentComment :: Typed.TypedTerm Dtld.Component -> Typed.TypedTerm (Maybe String)
componentComment x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
        Model.projectionFieldName = (Model.Name "comment")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.azure.dtld.Component
componentComponent :: Typed.TypedName Dtld.Component
componentComponent = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.Component")

-- | DSL accessor for the description field of hydra.ext.azure.dtld.Component
componentDescription :: Typed.TypedTerm Dtld.Component -> Typed.TypedTerm (Maybe String)
componentDescription x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
        Model.projectionFieldName = (Model.Name "description")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.Component
componentDisplayName :: Typed.TypedTerm Dtld.Component -> Typed.TypedTerm (Maybe String)
componentDisplayName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
        Model.projectionFieldName = (Model.Name "displayName")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the id field of hydra.ext.azure.dtld.Component
componentId :: Typed.TypedTerm Dtld.Component -> Typed.TypedTerm (Maybe Dtld.Dtmi)
componentId x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
        Model.projectionFieldName = (Model.Name "id")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the name field of hydra.ext.azure.dtld.Component
componentName :: Typed.TypedTerm Dtld.Component -> Typed.TypedTerm String
componentName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the schema field of hydra.ext.azure.dtld.Component
componentSchema :: Typed.TypedTerm Dtld.Component -> Typed.TypedTerm Dtld.Interface
componentSchema x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
        Model.projectionFieldName = (Model.Name "schema")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.azure.dtld.Component
componentType :: Typed.TypedTerm Dtld.Component -> Typed.TypedTerm Dtld.Iri
componentType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the comment field of hydra.ext.azure.dtld.Component
componentWithComment :: Typed.TypedTerm Dtld.Component -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Component
componentWithComment original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
      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.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the description field of hydra.ext.azure.dtld.Component
componentWithDescription :: Typed.TypedTerm Dtld.Component -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Component
componentWithDescription original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
      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.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the displayName field of hydra.ext.azure.dtld.Component
componentWithDisplayName :: Typed.TypedTerm Dtld.Component -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Component
componentWithDisplayName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
      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.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the id field of hydra.ext.azure.dtld.Component
componentWithId :: Typed.TypedTerm Dtld.Component -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm Dtld.Component
componentWithId original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
      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.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.azure.dtld.Component
componentWithName :: Typed.TypedTerm Dtld.Component -> Typed.TypedTerm String -> Typed.TypedTerm Dtld.Component
componentWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
      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.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the schema field of hydra.ext.azure.dtld.Component
componentWithSchema :: Typed.TypedTerm Dtld.Component -> Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm Dtld.Component
componentWithSchema original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
      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.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          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.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.azure.dtld.Component
componentWithType :: Typed.TypedTerm Dtld.Component -> Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm Dtld.Component
componentWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          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.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Component"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for the hydra.ext.azure.dtld.Dtmi wrapper
dtmi :: Typed.TypedTerm String -> Typed.TypedTerm Dtld.Dtmi
dtmi x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.azure.dtld.Dtmi"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.azure.dtld.Dtmi
dtmiDtmi :: Typed.TypedName Dtld.Dtmi
dtmiDtmi = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.Dtmi")

-- | DSL constructor for hydra.ext.azure.dtld.EnumValue
enumValue :: Typed.TypedTerm String -> Typed.TypedTerm Dtld.IntegerOrString -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.EnumValue
enumValue name enumValue id comment description displayName =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "enumValue"),
          Model.fieldTerm = (Typed.unTypedTerm enumValue)},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm id)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm comment)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm description)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm displayName)}]}))

-- | DSL accessor for the comment field of hydra.ext.azure.dtld.EnumValue
enumValueComment :: Typed.TypedTerm Dtld.EnumValue -> Typed.TypedTerm (Maybe String)
enumValueComment x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
        Model.projectionFieldName = (Model.Name "comment")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the description field of hydra.ext.azure.dtld.EnumValue
enumValueDescription :: Typed.TypedTerm Dtld.EnumValue -> Typed.TypedTerm (Maybe String)
enumValueDescription x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
        Model.projectionFieldName = (Model.Name "description")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.EnumValue
enumValueDisplayName :: Typed.TypedTerm Dtld.EnumValue -> Typed.TypedTerm (Maybe String)
enumValueDisplayName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
        Model.projectionFieldName = (Model.Name "displayName")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.azure.dtld.EnumValue
enumValueEnumValue :: Typed.TypedName Dtld.EnumValue
enumValueEnumValue = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.EnumValue")

-- | DSL accessor for the enumValue field of hydra.ext.azure.dtld.EnumValue
enumValueEnumValue2 :: Typed.TypedTerm Dtld.EnumValue -> Typed.TypedTerm Dtld.IntegerOrString
enumValueEnumValue2 x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
        Model.projectionFieldName = (Model.Name "enumValue")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the id field of hydra.ext.azure.dtld.EnumValue
enumValueId :: Typed.TypedTerm Dtld.EnumValue -> Typed.TypedTerm (Maybe Dtld.Dtmi)
enumValueId x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
        Model.projectionFieldName = (Model.Name "id")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

-- | DSL updater for the comment field of hydra.ext.azure.dtld.EnumValue
enumValueWithComment :: Typed.TypedTerm Dtld.EnumValue -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.EnumValue
enumValueWithComment original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "enumValue"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
              Model.projectionFieldName = (Model.Name "enumValue")})),
            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.azure.dtld.EnumValue"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the description field of hydra.ext.azure.dtld.EnumValue
enumValueWithDescription :: Typed.TypedTerm Dtld.EnumValue -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.EnumValue
enumValueWithDescription original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "enumValue"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
              Model.projectionFieldName = (Model.Name "enumValue")})),
            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.azure.dtld.EnumValue"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the displayName field of hydra.ext.azure.dtld.EnumValue
enumValueWithDisplayName :: Typed.TypedTerm Dtld.EnumValue -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.EnumValue
enumValueWithDisplayName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "enumValue"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
              Model.projectionFieldName = (Model.Name "enumValue")})),
            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.azure.dtld.EnumValue"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the enumValue field of hydra.ext.azure.dtld.EnumValue
enumValueWithEnumValue :: Typed.TypedTerm Dtld.EnumValue -> Typed.TypedTerm Dtld.IntegerOrString -> Typed.TypedTerm Dtld.EnumValue
enumValueWithEnumValue original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "enumValue"),
          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.azure.dtld.EnumValue"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the id field of hydra.ext.azure.dtld.EnumValue
enumValueWithId :: Typed.TypedTerm Dtld.EnumValue -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm Dtld.EnumValue
enumValueWithId original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "enumValue"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
              Model.projectionFieldName = (Model.Name "enumValue")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.azure.dtld.EnumValue
enumValueWithName :: Typed.TypedTerm Dtld.EnumValue -> Typed.TypedTerm String -> Typed.TypedTerm Dtld.EnumValue
enumValueWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "enumValue"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
              Model.projectionFieldName = (Model.Name "enumValue")})),
            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.azure.dtld.EnumValue"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.EnumValue"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.azure.dtld.Field
field :: Typed.TypedTerm String -> Typed.TypedTerm Dtld.Schema -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Field
field name schema id comment description displayName =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Typed.unTypedTerm schema)},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm id)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm comment)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm description)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm displayName)}]}))

-- | DSL accessor for the comment field of hydra.ext.azure.dtld.Field
fieldComment :: Typed.TypedTerm Dtld.Field -> Typed.TypedTerm (Maybe String)
fieldComment x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
        Model.projectionFieldName = (Model.Name "comment")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the description field of hydra.ext.azure.dtld.Field
fieldDescription :: Typed.TypedTerm Dtld.Field -> Typed.TypedTerm (Maybe String)
fieldDescription x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
        Model.projectionFieldName = (Model.Name "description")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.Field
fieldDisplayName :: Typed.TypedTerm Dtld.Field -> Typed.TypedTerm (Maybe String)
fieldDisplayName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
        Model.projectionFieldName = (Model.Name "displayName")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.azure.dtld.Field
fieldField :: Typed.TypedName Dtld.Field
fieldField = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.Field")

-- | DSL accessor for the id field of hydra.ext.azure.dtld.Field
fieldId :: Typed.TypedTerm Dtld.Field -> Typed.TypedTerm (Maybe Dtld.Dtmi)
fieldId x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
        Model.projectionFieldName = (Model.Name "id")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

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

-- | DSL updater for the comment field of hydra.ext.azure.dtld.Field
fieldWithComment :: Typed.TypedTerm Dtld.Field -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Field
fieldWithComment original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.Field"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the description field of hydra.ext.azure.dtld.Field
fieldWithDescription :: Typed.TypedTerm Dtld.Field -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Field
fieldWithDescription original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.Field"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the displayName field of hydra.ext.azure.dtld.Field
fieldWithDisplayName :: Typed.TypedTerm Dtld.Field -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Field
fieldWithDisplayName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.Field"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the id field of hydra.ext.azure.dtld.Field
fieldWithId :: Typed.TypedTerm Dtld.Field -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm Dtld.Field
fieldWithId original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.azure.dtld.Field
fieldWithName :: Typed.TypedTerm Dtld.Field -> Typed.TypedTerm String -> Typed.TypedTerm Dtld.Field
fieldWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.Field"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the schema field of hydra.ext.azure.dtld.Field
fieldWithSchema :: Typed.TypedTerm Dtld.Field -> Typed.TypedTerm Dtld.Schema -> Typed.TypedTerm Dtld.Field
fieldWithSchema original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          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.azure.dtld.Field"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Field"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the integer variant of hydra.ext.azure.dtld.IntegerOrString
integerOrStringInteger :: Typed.TypedTerm Int -> Typed.TypedTerm Dtld.IntegerOrString
integerOrStringInteger x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.IntegerOrString"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "integer"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.azure.dtld.IntegerOrString
integerOrStringIntegerOrString :: Typed.TypedName Dtld.IntegerOrString
integerOrStringIntegerOrString = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.IntegerOrString")

-- | DSL injection for the string variant of hydra.ext.azure.dtld.IntegerOrString
integerOrStringString :: Typed.TypedTerm String -> Typed.TypedTerm Dtld.IntegerOrString
integerOrStringString x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.IntegerOrString"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "string"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.ext.azure.dtld.Interface
interface :: Typed.TypedTerm Dtld.Dtmi -> Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe (S.Set Dtld.InterfaceContents)) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe (S.Set Dtld.Interface)) -> Typed.TypedTerm (Maybe (S.Set Dtld.SchemaInterface)) -> Typed.TypedTerm Dtld.Interface
interface id type_ context comment contents description displayName extends schemas =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm id)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "context"),
          Model.fieldTerm = (Typed.unTypedTerm context)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm comment)},
        Model.Field {
          Model.fieldName = (Model.Name "contents"),
          Model.fieldTerm = (Typed.unTypedTerm contents)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm description)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm displayName)},
        Model.Field {
          Model.fieldName = (Model.Name "extends"),
          Model.fieldTerm = (Typed.unTypedTerm extends)},
        Model.Field {
          Model.fieldName = (Model.Name "schemas"),
          Model.fieldTerm = (Typed.unTypedTerm schemas)}]}))

-- | DSL accessor for the comment field of hydra.ext.azure.dtld.Interface
interfaceComment :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm (Maybe String)
interfaceComment x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
        Model.projectionFieldName = (Model.Name "comment")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the contents field of hydra.ext.azure.dtld.Interface
interfaceContents :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm (Maybe (S.Set Dtld.InterfaceContents))
interfaceContents x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
        Model.projectionFieldName = (Model.Name "contents")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL injection for the command variant of hydra.ext.azure.dtld.InterfaceContents
interfaceContentsCommand :: Typed.TypedTerm Dtld.Command -> Typed.TypedTerm Dtld.InterfaceContents
interfaceContentsCommand x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.InterfaceContents"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "command"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the component variant of hydra.ext.azure.dtld.InterfaceContents
interfaceContentsComponent :: Typed.TypedTerm Dtld.Component -> Typed.TypedTerm Dtld.InterfaceContents
interfaceContentsComponent x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.InterfaceContents"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "component"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.azure.dtld.InterfaceContents
interfaceContentsInterfaceContents :: Typed.TypedName Dtld.InterfaceContents
interfaceContentsInterfaceContents = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.InterfaceContents")

-- | DSL injection for the property variant of hydra.ext.azure.dtld.InterfaceContents
interfaceContentsProperty :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm Dtld.InterfaceContents
interfaceContentsProperty x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.InterfaceContents"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "property"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the relationship variant of hydra.ext.azure.dtld.InterfaceContents
interfaceContentsRelationship :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm Dtld.InterfaceContents
interfaceContentsRelationship x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.InterfaceContents"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "relationship"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the telemetry variant of hydra.ext.azure.dtld.InterfaceContents
interfaceContentsTelemetry :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm Dtld.InterfaceContents
interfaceContentsTelemetry x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.InterfaceContents"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "telemetry"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL accessor for the context field of hydra.ext.azure.dtld.Interface
interfaceContext :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm Dtld.Iri
interfaceContext x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
        Model.projectionFieldName = (Model.Name "context")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the description field of hydra.ext.azure.dtld.Interface
interfaceDescription :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm (Maybe String)
interfaceDescription x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
        Model.projectionFieldName = (Model.Name "description")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.Interface
interfaceDisplayName :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm (Maybe String)
interfaceDisplayName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
        Model.projectionFieldName = (Model.Name "displayName")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the extends field of hydra.ext.azure.dtld.Interface
interfaceExtends :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm (Maybe (S.Set Dtld.Interface))
interfaceExtends x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
        Model.projectionFieldName = (Model.Name "extends")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the id field of hydra.ext.azure.dtld.Interface
interfaceId :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm Dtld.Dtmi
interfaceId x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
        Model.projectionFieldName = (Model.Name "id")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.azure.dtld.Interface
interfaceInterface :: Typed.TypedName Dtld.Interface
interfaceInterface = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.Interface")

-- | DSL accessor for the schemas field of hydra.ext.azure.dtld.Interface
interfaceSchemas :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm (Maybe (S.Set Dtld.SchemaInterface))
interfaceSchemas x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
        Model.projectionFieldName = (Model.Name "schemas")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.azure.dtld.Interface
interfaceType :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm Dtld.Iri
interfaceType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the comment field of hydra.ext.azure.dtld.Interface
interfaceWithComment :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Interface
interfaceWithComment original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
      Model.recordFields = [
        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.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "context"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "context")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "contents"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "contents")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "extends"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "extends")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schemas"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "schemas")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the contents field of hydra.ext.azure.dtld.Interface
interfaceWithContents :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm (Maybe (S.Set Dtld.InterfaceContents)) -> Typed.TypedTerm Dtld.Interface
interfaceWithContents original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
      Model.recordFields = [
        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.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "context"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "context")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "contents"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "extends"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "extends")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schemas"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "schemas")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the context field of hydra.ext.azure.dtld.Interface
interfaceWithContext :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm Dtld.Interface
interfaceWithContext original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
      Model.recordFields = [
        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.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "context"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "contents"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "contents")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "extends"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "extends")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schemas"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "schemas")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the description field of hydra.ext.azure.dtld.Interface
interfaceWithDescription :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Interface
interfaceWithDescription original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
      Model.recordFields = [
        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.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "context"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "context")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "contents"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "contents")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "extends"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "extends")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schemas"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "schemas")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the displayName field of hydra.ext.azure.dtld.Interface
interfaceWithDisplayName :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Interface
interfaceWithDisplayName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
      Model.recordFields = [
        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.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "context"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "context")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "contents"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "contents")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "extends"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "extends")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schemas"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "schemas")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the extends field of hydra.ext.azure.dtld.Interface
interfaceWithExtends :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm (Maybe (S.Set Dtld.Interface)) -> Typed.TypedTerm Dtld.Interface
interfaceWithExtends original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
      Model.recordFields = [
        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.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "context"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "context")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "contents"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "contents")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "extends"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "schemas"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "schemas")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the id field of hydra.ext.azure.dtld.Interface
interfaceWithId :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm Dtld.Dtmi -> Typed.TypedTerm Dtld.Interface
interfaceWithId original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "context"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "context")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "contents"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "contents")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "extends"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "extends")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schemas"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "schemas")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the schemas field of hydra.ext.azure.dtld.Interface
interfaceWithSchemas :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm (Maybe (S.Set Dtld.SchemaInterface)) -> Typed.TypedTerm Dtld.Interface
interfaceWithSchemas original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
      Model.recordFields = [
        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.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "context"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "context")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "contents"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "contents")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "extends"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "extends")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schemas"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the type field of hydra.ext.azure.dtld.Interface
interfaceWithType :: Typed.TypedTerm Dtld.Interface -> Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm Dtld.Interface
interfaceWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
      Model.recordFields = [
        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.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "context"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "context")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "contents"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "contents")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "extends"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "extends")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schemas"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Interface"),
              Model.projectionFieldName = (Model.Name "schemas")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for the hydra.ext.azure.dtld.Iri wrapper
iri :: Typed.TypedTerm String -> Typed.TypedTerm Dtld.Iri
iri x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.azure.dtld.Iri"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.azure.dtld.Iri
iriIri :: Typed.TypedName Dtld.Iri
iriIri = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.Iri")

-- | DSL constructor for hydra.ext.azure.dtld.MapKey
mapKey :: Typed.TypedTerm String -> Typed.TypedTerm Dtld.Schema -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.MapKey
mapKey name schema id comment description displayName =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Typed.unTypedTerm schema)},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm id)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm comment)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm description)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm displayName)}]}))

-- | DSL accessor for the comment field of hydra.ext.azure.dtld.MapKey
mapKeyComment :: Typed.TypedTerm Dtld.MapKey -> Typed.TypedTerm (Maybe String)
mapKeyComment x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
        Model.projectionFieldName = (Model.Name "comment")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the description field of hydra.ext.azure.dtld.MapKey
mapKeyDescription :: Typed.TypedTerm Dtld.MapKey -> Typed.TypedTerm (Maybe String)
mapKeyDescription x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
        Model.projectionFieldName = (Model.Name "description")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.MapKey
mapKeyDisplayName :: Typed.TypedTerm Dtld.MapKey -> Typed.TypedTerm (Maybe String)
mapKeyDisplayName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
        Model.projectionFieldName = (Model.Name "displayName")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the id field of hydra.ext.azure.dtld.MapKey
mapKeyId :: Typed.TypedTerm Dtld.MapKey -> Typed.TypedTerm (Maybe Dtld.Dtmi)
mapKeyId x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
        Model.projectionFieldName = (Model.Name "id")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.azure.dtld.MapKey
mapKeyMapKey :: Typed.TypedName Dtld.MapKey
mapKeyMapKey = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.MapKey")

-- | DSL accessor for the name field of hydra.ext.azure.dtld.MapKey
mapKeyName :: Typed.TypedTerm Dtld.MapKey -> Typed.TypedTerm String
mapKeyName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

-- | DSL updater for the comment field of hydra.ext.azure.dtld.MapKey
mapKeyWithComment :: Typed.TypedTerm Dtld.MapKey -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.MapKey
mapKeyWithComment original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
      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.azure.dtld.MapKey"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.MapKey"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the description field of hydra.ext.azure.dtld.MapKey
mapKeyWithDescription :: Typed.TypedTerm Dtld.MapKey -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.MapKey
mapKeyWithDescription original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
      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.azure.dtld.MapKey"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.MapKey"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the displayName field of hydra.ext.azure.dtld.MapKey
mapKeyWithDisplayName :: Typed.TypedTerm Dtld.MapKey -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.MapKey
mapKeyWithDisplayName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
      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.azure.dtld.MapKey"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.MapKey"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the id field of hydra.ext.azure.dtld.MapKey
mapKeyWithId :: Typed.TypedTerm Dtld.MapKey -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm Dtld.MapKey
mapKeyWithId original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
      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.azure.dtld.MapKey"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.azure.dtld.MapKey
mapKeyWithName :: Typed.TypedTerm Dtld.MapKey -> Typed.TypedTerm String -> Typed.TypedTerm Dtld.MapKey
mapKeyWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.MapKey"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the schema field of hydra.ext.azure.dtld.MapKey
mapKeyWithSchema :: Typed.TypedTerm Dtld.MapKey -> Typed.TypedTerm Dtld.Schema -> Typed.TypedTerm Dtld.MapKey
mapKeyWithSchema original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
      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.azure.dtld.MapKey"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          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.azure.dtld.MapKey"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapKey"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.azure.dtld.MapValue
mapValue :: Typed.TypedTerm String -> Typed.TypedTerm Dtld.Schema -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.MapValue
mapValue name schema id comment description displayName =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Typed.unTypedTerm schema)},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm id)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm comment)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm description)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm displayName)}]}))

-- | DSL accessor for the comment field of hydra.ext.azure.dtld.MapValue
mapValueComment :: Typed.TypedTerm Dtld.MapValue -> Typed.TypedTerm (Maybe String)
mapValueComment x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
        Model.projectionFieldName = (Model.Name "comment")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the description field of hydra.ext.azure.dtld.MapValue
mapValueDescription :: Typed.TypedTerm Dtld.MapValue -> Typed.TypedTerm (Maybe String)
mapValueDescription x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
        Model.projectionFieldName = (Model.Name "description")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.MapValue
mapValueDisplayName :: Typed.TypedTerm Dtld.MapValue -> Typed.TypedTerm (Maybe String)
mapValueDisplayName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
        Model.projectionFieldName = (Model.Name "displayName")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the id field of hydra.ext.azure.dtld.MapValue
mapValueId :: Typed.TypedTerm Dtld.MapValue -> Typed.TypedTerm (Maybe Dtld.Dtmi)
mapValueId x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
        Model.projectionFieldName = (Model.Name "id")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.azure.dtld.MapValue
mapValueMapValue :: Typed.TypedName Dtld.MapValue
mapValueMapValue = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.MapValue")

-- | DSL accessor for the name field of hydra.ext.azure.dtld.MapValue
mapValueName :: Typed.TypedTerm Dtld.MapValue -> Typed.TypedTerm String
mapValueName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

-- | DSL updater for the comment field of hydra.ext.azure.dtld.MapValue
mapValueWithComment :: Typed.TypedTerm Dtld.MapValue -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.MapValue
mapValueWithComment original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
      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.azure.dtld.MapValue"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.MapValue"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the description field of hydra.ext.azure.dtld.MapValue
mapValueWithDescription :: Typed.TypedTerm Dtld.MapValue -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.MapValue
mapValueWithDescription original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
      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.azure.dtld.MapValue"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.MapValue"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the displayName field of hydra.ext.azure.dtld.MapValue
mapValueWithDisplayName :: Typed.TypedTerm Dtld.MapValue -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.MapValue
mapValueWithDisplayName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
      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.azure.dtld.MapValue"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.MapValue"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the id field of hydra.ext.azure.dtld.MapValue
mapValueWithId :: Typed.TypedTerm Dtld.MapValue -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm Dtld.MapValue
mapValueWithId original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
      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.azure.dtld.MapValue"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.azure.dtld.MapValue
mapValueWithName :: Typed.TypedTerm Dtld.MapValue -> Typed.TypedTerm String -> Typed.TypedTerm Dtld.MapValue
mapValueWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.MapValue"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the schema field of hydra.ext.azure.dtld.MapValue
mapValueWithSchema :: Typed.TypedTerm Dtld.MapValue -> Typed.TypedTerm Dtld.Schema -> Typed.TypedTerm Dtld.MapValue
mapValueWithSchema original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
      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.azure.dtld.MapValue"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          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.azure.dtld.MapValue"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.MapValue"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.azure.dtld.Property
property :: Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm String -> Typed.TypedTerm Dtld.Schema -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe Dtld.Unit) -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Dtld.Property
property type_ name schema id comment description displayName unit writable =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Typed.unTypedTerm schema)},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm id)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm comment)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm description)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm displayName)},
        Model.Field {
          Model.fieldName = (Model.Name "unit"),
          Model.fieldTerm = (Typed.unTypedTerm unit)},
        Model.Field {
          Model.fieldName = (Model.Name "writable"),
          Model.fieldTerm = (Typed.unTypedTerm writable)}]}))

-- | DSL accessor for the comment field of hydra.ext.azure.dtld.Property
propertyComment :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm (Maybe String)
propertyComment x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
        Model.projectionFieldName = (Model.Name "comment")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the description field of hydra.ext.azure.dtld.Property
propertyDescription :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm (Maybe String)
propertyDescription x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
        Model.projectionFieldName = (Model.Name "description")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.Property
propertyDisplayName :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm (Maybe String)
propertyDisplayName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
        Model.projectionFieldName = (Model.Name "displayName")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the id field of hydra.ext.azure.dtld.Property
propertyId :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm (Maybe Dtld.Dtmi)
propertyId x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
        Model.projectionFieldName = (Model.Name "id")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the name field of hydra.ext.azure.dtld.Property
propertyName :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm String
propertyName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.azure.dtld.Property
propertyProperty :: Typed.TypedName Dtld.Property
propertyProperty = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.Property")

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

-- | DSL accessor for the type field of hydra.ext.azure.dtld.Property
propertyType :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm Dtld.Iri
propertyType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the unit field of hydra.ext.azure.dtld.Property
propertyUnit :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm (Maybe Dtld.Unit)
propertyUnit x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
        Model.projectionFieldName = (Model.Name "unit")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the comment field of hydra.ext.azure.dtld.Property
propertyWithComment :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Property
propertyWithComment original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
      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.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "unit"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "unit")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "writable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "writable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the description field of hydra.ext.azure.dtld.Property
propertyWithDescription :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Property
propertyWithDescription original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
      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.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "unit"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "unit")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "writable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "writable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the displayName field of hydra.ext.azure.dtld.Property
propertyWithDisplayName :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Property
propertyWithDisplayName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
      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.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "unit"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "unit")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "writable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "writable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the id field of hydra.ext.azure.dtld.Property
propertyWithId :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm Dtld.Property
propertyWithId original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
      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.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "unit"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "unit")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "writable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "writable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.azure.dtld.Property
propertyWithName :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm String -> Typed.TypedTerm Dtld.Property
propertyWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
      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.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "unit"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "unit")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "writable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "writable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the schema field of hydra.ext.azure.dtld.Property
propertyWithSchema :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm Dtld.Schema -> Typed.TypedTerm Dtld.Property
propertyWithSchema original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
      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.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          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.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "unit"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "unit")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "writable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "writable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.azure.dtld.Property
propertyWithType :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm Dtld.Property
propertyWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          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.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "unit"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "unit")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "writable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "writable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the unit field of hydra.ext.azure.dtld.Property
propertyWithUnit :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm (Maybe Dtld.Unit) -> Typed.TypedTerm Dtld.Property
propertyWithUnit original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
      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.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "unit"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "writable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "writable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the writable field of hydra.ext.azure.dtld.Property
propertyWithWritable :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Dtld.Property
propertyWithWritable original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
      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.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "unit"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
              Model.projectionFieldName = (Model.Name "unit")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "writable"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL accessor for the writable field of hydra.ext.azure.dtld.Property
propertyWritable :: Typed.TypedTerm Dtld.Property -> Typed.TypedTerm (Maybe Bool)
propertyWritable x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Property"),
        Model.projectionFieldName = (Model.Name "writable")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL constructor for hydra.ext.azure.dtld.Relationship
relationship :: Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm String -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm (Maybe (S.Set Dtld.Property)) -> Typed.TypedTerm (Maybe Dtld.Interface) -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Dtld.Relationship
relationship type_ name id comment description displayName maxMultiplicity minMultiplicity properties target writable =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm id)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm comment)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm description)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm displayName)},
        Model.Field {
          Model.fieldName = (Model.Name "maxMultiplicity"),
          Model.fieldTerm = (Typed.unTypedTerm maxMultiplicity)},
        Model.Field {
          Model.fieldName = (Model.Name "minMultiplicity"),
          Model.fieldTerm = (Typed.unTypedTerm minMultiplicity)},
        Model.Field {
          Model.fieldName = (Model.Name "properties"),
          Model.fieldTerm = (Typed.unTypedTerm properties)},
        Model.Field {
          Model.fieldName = (Model.Name "target"),
          Model.fieldTerm = (Typed.unTypedTerm target)},
        Model.Field {
          Model.fieldName = (Model.Name "writable"),
          Model.fieldTerm = (Typed.unTypedTerm writable)}]}))

-- | DSL accessor for the comment field of hydra.ext.azure.dtld.Relationship
relationshipComment :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe String)
relationshipComment x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
        Model.projectionFieldName = (Model.Name "comment")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the description field of hydra.ext.azure.dtld.Relationship
relationshipDescription :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe String)
relationshipDescription x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
        Model.projectionFieldName = (Model.Name "description")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.Relationship
relationshipDisplayName :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe String)
relationshipDisplayName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
        Model.projectionFieldName = (Model.Name "displayName")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the id field of hydra.ext.azure.dtld.Relationship
relationshipId :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe Dtld.Dtmi)
relationshipId x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
        Model.projectionFieldName = (Model.Name "id")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the maxMultiplicity field of hydra.ext.azure.dtld.Relationship
relationshipMaxMultiplicity :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe Int)
relationshipMaxMultiplicity x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
        Model.projectionFieldName = (Model.Name "maxMultiplicity")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the minMultiplicity field of hydra.ext.azure.dtld.Relationship
relationshipMinMultiplicity :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe Int)
relationshipMinMultiplicity x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
        Model.projectionFieldName = (Model.Name "minMultiplicity")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the name field of hydra.ext.azure.dtld.Relationship
relationshipName :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm String
relationshipName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the properties field of hydra.ext.azure.dtld.Relationship
relationshipProperties :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe (S.Set Dtld.Property))
relationshipProperties x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
        Model.projectionFieldName = (Model.Name "properties")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.azure.dtld.Relationship
relationshipRelationship :: Typed.TypedName Dtld.Relationship
relationshipRelationship = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.Relationship")

-- | DSL accessor for the target field of hydra.ext.azure.dtld.Relationship
relationshipTarget :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe Dtld.Interface)
relationshipTarget x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
        Model.projectionFieldName = (Model.Name "target")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the type field of hydra.ext.azure.dtld.Relationship
relationshipType :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm Dtld.Iri
relationshipType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the comment field of hydra.ext.azure.dtld.Relationship
relationshipWithComment :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Relationship
relationshipWithComment original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
      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.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "name")})),
            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.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "maxMultiplicity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "maxMultiplicity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "minMultiplicity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "minMultiplicity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "properties"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "properties")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "target"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "target")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "writable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "writable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the description field of hydra.ext.azure.dtld.Relationship
relationshipWithDescription :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Relationship
relationshipWithDescription original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
      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.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "name")})),
            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.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "maxMultiplicity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "maxMultiplicity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "minMultiplicity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "minMultiplicity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "properties"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "properties")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "target"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "target")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "writable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "writable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the displayName field of hydra.ext.azure.dtld.Relationship
relationshipWithDisplayName :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Relationship
relationshipWithDisplayName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
      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.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "name")})),
            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.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "maxMultiplicity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "maxMultiplicity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "minMultiplicity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "minMultiplicity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "properties"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "properties")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "target"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "target")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "writable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "writable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the id field of hydra.ext.azure.dtld.Relationship
relationshipWithId :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm Dtld.Relationship
relationshipWithId original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
      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.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "maxMultiplicity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "maxMultiplicity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "minMultiplicity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "minMultiplicity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "properties"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "properties")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "target"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "target")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "writable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "writable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the maxMultiplicity field of hydra.ext.azure.dtld.Relationship
relationshipWithMaxMultiplicity :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm Dtld.Relationship
relationshipWithMaxMultiplicity original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
      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.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "name")})),
            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.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "maxMultiplicity"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "minMultiplicity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "minMultiplicity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "properties"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "properties")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "target"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "target")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "writable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "writable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the minMultiplicity field of hydra.ext.azure.dtld.Relationship
relationshipWithMinMultiplicity :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe Int) -> Typed.TypedTerm Dtld.Relationship
relationshipWithMinMultiplicity original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
      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.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "name")})),
            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.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "maxMultiplicity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "maxMultiplicity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "minMultiplicity"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "properties"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "properties")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "target"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "target")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "writable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "writable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.azure.dtld.Relationship
relationshipWithName :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm String -> Typed.TypedTerm Dtld.Relationship
relationshipWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
      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.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          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.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "maxMultiplicity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "maxMultiplicity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "minMultiplicity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "minMultiplicity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "properties"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "properties")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "target"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "target")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "writable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "writable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the properties field of hydra.ext.azure.dtld.Relationship
relationshipWithProperties :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe (S.Set Dtld.Property)) -> Typed.TypedTerm Dtld.Relationship
relationshipWithProperties original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
      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.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "name")})),
            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.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "maxMultiplicity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "maxMultiplicity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "minMultiplicity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "minMultiplicity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "properties"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "target"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "target")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "writable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "writable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the target field of hydra.ext.azure.dtld.Relationship
relationshipWithTarget :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe Dtld.Interface) -> Typed.TypedTerm Dtld.Relationship
relationshipWithTarget original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
      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.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "name")})),
            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.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "maxMultiplicity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "maxMultiplicity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "minMultiplicity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "minMultiplicity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "properties"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "properties")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "target"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "writable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "writable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.azure.dtld.Relationship
relationshipWithType :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm Dtld.Relationship
relationshipWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          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.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "name")})),
            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.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "maxMultiplicity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "maxMultiplicity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "minMultiplicity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "minMultiplicity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "properties"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "properties")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "target"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "target")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "writable"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "writable")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the writable field of hydra.ext.azure.dtld.Relationship
relationshipWithWritable :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Dtld.Relationship
relationshipWithWritable original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
      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.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "name")})),
            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.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "maxMultiplicity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "maxMultiplicity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "minMultiplicity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "minMultiplicity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "properties"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "properties")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "target"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
              Model.projectionFieldName = (Model.Name "target")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "writable"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL accessor for the writable field of hydra.ext.azure.dtld.Relationship
relationshipWritable :: Typed.TypedTerm Dtld.Relationship -> Typed.TypedTerm (Maybe Bool)
relationshipWritable x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Relationship"),
        Model.projectionFieldName = (Model.Name "writable")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL constructor for hydra.ext.azure.dtld.SchemaArray
schemaArray :: Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm Dtld.Schema -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaArray
schemaArray type_ elementSchema id comment description displayName =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "elementSchema"),
          Model.fieldTerm = (Typed.unTypedTerm elementSchema)},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm id)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm comment)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm description)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm displayName)}]}))

-- | DSL accessor for the comment field of hydra.ext.azure.dtld.SchemaArray
schemaArrayComment :: Typed.TypedTerm Dtld.SchemaArray -> Typed.TypedTerm (Maybe String)
schemaArrayComment x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
        Model.projectionFieldName = (Model.Name "comment")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the description field of hydra.ext.azure.dtld.SchemaArray
schemaArrayDescription :: Typed.TypedTerm Dtld.SchemaArray -> Typed.TypedTerm (Maybe String)
schemaArrayDescription x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
        Model.projectionFieldName = (Model.Name "description")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.SchemaArray
schemaArrayDisplayName :: Typed.TypedTerm Dtld.SchemaArray -> Typed.TypedTerm (Maybe String)
schemaArrayDisplayName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
        Model.projectionFieldName = (Model.Name "displayName")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the elementSchema field of hydra.ext.azure.dtld.SchemaArray
schemaArrayElementSchema :: Typed.TypedTerm Dtld.SchemaArray -> Typed.TypedTerm Dtld.Schema
schemaArrayElementSchema x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
        Model.projectionFieldName = (Model.Name "elementSchema")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the id field of hydra.ext.azure.dtld.SchemaArray
schemaArrayId :: Typed.TypedTerm Dtld.SchemaArray -> Typed.TypedTerm (Maybe Dtld.Dtmi)
schemaArrayId x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
        Model.projectionFieldName = (Model.Name "id")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.azure.dtld.SchemaArray
schemaArraySchemaArray :: Typed.TypedName Dtld.SchemaArray
schemaArraySchemaArray = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.SchemaArray")

-- | DSL accessor for the type field of hydra.ext.azure.dtld.SchemaArray
schemaArrayType :: Typed.TypedTerm Dtld.SchemaArray -> Typed.TypedTerm Dtld.Iri
schemaArrayType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the comment field of hydra.ext.azure.dtld.SchemaArray
schemaArrayWithComment :: Typed.TypedTerm Dtld.SchemaArray -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaArray
schemaArrayWithComment original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
      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.azure.dtld.SchemaArray"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "elementSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
              Model.projectionFieldName = (Model.Name "elementSchema")})),
            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.azure.dtld.SchemaArray"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the description field of hydra.ext.azure.dtld.SchemaArray
schemaArrayWithDescription :: Typed.TypedTerm Dtld.SchemaArray -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaArray
schemaArrayWithDescription original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
      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.azure.dtld.SchemaArray"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "elementSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
              Model.projectionFieldName = (Model.Name "elementSchema")})),
            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.azure.dtld.SchemaArray"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the displayName field of hydra.ext.azure.dtld.SchemaArray
schemaArrayWithDisplayName :: Typed.TypedTerm Dtld.SchemaArray -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaArray
schemaArrayWithDisplayName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
      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.azure.dtld.SchemaArray"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "elementSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
              Model.projectionFieldName = (Model.Name "elementSchema")})),
            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.azure.dtld.SchemaArray"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the elementSchema field of hydra.ext.azure.dtld.SchemaArray
schemaArrayWithElementSchema :: Typed.TypedTerm Dtld.SchemaArray -> Typed.TypedTerm Dtld.Schema -> Typed.TypedTerm Dtld.SchemaArray
schemaArrayWithElementSchema original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
      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.azure.dtld.SchemaArray"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "elementSchema"),
          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.azure.dtld.SchemaArray"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the id field of hydra.ext.azure.dtld.SchemaArray
schemaArrayWithId :: Typed.TypedTerm Dtld.SchemaArray -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm Dtld.SchemaArray
schemaArrayWithId original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
      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.azure.dtld.SchemaArray"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "elementSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
              Model.projectionFieldName = (Model.Name "elementSchema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.azure.dtld.SchemaArray
schemaArrayWithType :: Typed.TypedTerm Dtld.SchemaArray -> Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm Dtld.SchemaArray
schemaArrayWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "elementSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
              Model.projectionFieldName = (Model.Name "elementSchema")})),
            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.azure.dtld.SchemaArray"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaArray"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the complex variant of hydra.ext.azure.dtld.Schema
schemaComplex :: Typed.TypedTerm Dtld.SchemaComplex -> Typed.TypedTerm Dtld.Schema
schemaComplex x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.Schema"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "complex"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the array variant of hydra.ext.azure.dtld.SchemaComplex
schemaComplexArray :: Typed.TypedTerm Dtld.SchemaArray -> Typed.TypedTerm Dtld.SchemaComplex
schemaComplexArray x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaComplex"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "array"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the enum variant of hydra.ext.azure.dtld.SchemaComplex
schemaComplexEnum :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm Dtld.SchemaComplex
schemaComplexEnum x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaComplex"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "enum"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the map variant of hydra.ext.azure.dtld.SchemaComplex
schemaComplexMap :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm Dtld.SchemaComplex
schemaComplexMap x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaComplex"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "map"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the object variant of hydra.ext.azure.dtld.SchemaComplex
schemaComplexObject :: Typed.TypedTerm Dtld.SchemaObject -> Typed.TypedTerm Dtld.SchemaComplex
schemaComplexObject x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaComplex"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "object"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.azure.dtld.SchemaComplex
schemaComplexSchemaComplex :: Typed.TypedName Dtld.SchemaComplex
schemaComplexSchemaComplex = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.SchemaComplex")

-- | DSL constructor for hydra.ext.azure.dtld.SchemaEnum
schemaEnum :: Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm [Dtld.EnumValue] -> Typed.TypedTerm Dtld.IntegerOrString -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaEnum
schemaEnum type_ enumValues valueSchema id comment description displayName =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "enumValues"),
          Model.fieldTerm = (Typed.unTypedTerm enumValues)},
        Model.Field {
          Model.fieldName = (Model.Name "valueSchema"),
          Model.fieldTerm = (Typed.unTypedTerm valueSchema)},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm id)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm comment)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm description)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm displayName)}]}))

-- | DSL accessor for the comment field of hydra.ext.azure.dtld.SchemaEnum
schemaEnumComment :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm (Maybe String)
schemaEnumComment x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
        Model.projectionFieldName = (Model.Name "comment")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the description field of hydra.ext.azure.dtld.SchemaEnum
schemaEnumDescription :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm (Maybe String)
schemaEnumDescription x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
        Model.projectionFieldName = (Model.Name "description")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.SchemaEnum
schemaEnumDisplayName :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm (Maybe String)
schemaEnumDisplayName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
        Model.projectionFieldName = (Model.Name "displayName")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the enumValues field of hydra.ext.azure.dtld.SchemaEnum
schemaEnumEnumValues :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm [Dtld.EnumValue]
schemaEnumEnumValues x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
        Model.projectionFieldName = (Model.Name "enumValues")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the id field of hydra.ext.azure.dtld.SchemaEnum
schemaEnumId :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm (Maybe Dtld.Dtmi)
schemaEnumId x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
        Model.projectionFieldName = (Model.Name "id")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.azure.dtld.SchemaEnum
schemaEnumSchemaEnum :: Typed.TypedName Dtld.SchemaEnum
schemaEnumSchemaEnum = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.SchemaEnum")

-- | DSL accessor for the type field of hydra.ext.azure.dtld.SchemaEnum
schemaEnumType :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm Dtld.Iri
schemaEnumType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the valueSchema field of hydra.ext.azure.dtld.SchemaEnum
schemaEnumValueSchema :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm Dtld.IntegerOrString
schemaEnumValueSchema x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
        Model.projectionFieldName = (Model.Name "valueSchema")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the comment field of hydra.ext.azure.dtld.SchemaEnum
schemaEnumWithComment :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaEnum
schemaEnumWithComment original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
      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.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "enumValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "enumValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "valueSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "valueSchema")})),
            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.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the description field of hydra.ext.azure.dtld.SchemaEnum
schemaEnumWithDescription :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaEnum
schemaEnumWithDescription original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
      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.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "enumValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "enumValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "valueSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "valueSchema")})),
            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.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the displayName field of hydra.ext.azure.dtld.SchemaEnum
schemaEnumWithDisplayName :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaEnum
schemaEnumWithDisplayName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
      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.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "enumValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "enumValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "valueSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "valueSchema")})),
            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.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the enumValues field of hydra.ext.azure.dtld.SchemaEnum
schemaEnumWithEnumValues :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm [Dtld.EnumValue] -> Typed.TypedTerm Dtld.SchemaEnum
schemaEnumWithEnumValues original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
      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.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "enumValues"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "valueSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "valueSchema")})),
            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.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the id field of hydra.ext.azure.dtld.SchemaEnum
schemaEnumWithId :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm Dtld.SchemaEnum
schemaEnumWithId original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
      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.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "enumValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "enumValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "valueSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "valueSchema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.azure.dtld.SchemaEnum
schemaEnumWithType :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm Dtld.SchemaEnum
schemaEnumWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "enumValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "enumValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "valueSchema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "valueSchema")})),
            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.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the valueSchema field of hydra.ext.azure.dtld.SchemaEnum
schemaEnumWithValueSchema :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm Dtld.IntegerOrString -> Typed.TypedTerm Dtld.SchemaEnum
schemaEnumWithValueSchema original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
      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.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "enumValues"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "enumValues")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "valueSchema"),
          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.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaEnum"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.azure.dtld.SchemaInterface
schemaInterface :: Typed.TypedTerm Dtld.Dtmi -> Typed.TypedTerm Dtld.SchemaInterfaceType -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaInterface
schemaInterface id type_ comment description displayName =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm id)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm comment)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm description)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm displayName)}]}))

-- | DSL accessor for the comment field of hydra.ext.azure.dtld.SchemaInterface
schemaInterfaceComment :: Typed.TypedTerm Dtld.SchemaInterface -> Typed.TypedTerm (Maybe String)
schemaInterfaceComment x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"),
        Model.projectionFieldName = (Model.Name "comment")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the description field of hydra.ext.azure.dtld.SchemaInterface
schemaInterfaceDescription :: Typed.TypedTerm Dtld.SchemaInterface -> Typed.TypedTerm (Maybe String)
schemaInterfaceDescription x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"),
        Model.projectionFieldName = (Model.Name "description")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.SchemaInterface
schemaInterfaceDisplayName :: Typed.TypedTerm Dtld.SchemaInterface -> Typed.TypedTerm (Maybe String)
schemaInterfaceDisplayName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"),
        Model.projectionFieldName = (Model.Name "displayName")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the id field of hydra.ext.azure.dtld.SchemaInterface
schemaInterfaceId :: Typed.TypedTerm Dtld.SchemaInterface -> Typed.TypedTerm Dtld.Dtmi
schemaInterfaceId x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"),
        Model.projectionFieldName = (Model.Name "id")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.azure.dtld.SchemaInterface
schemaInterfaceSchemaInterface :: Typed.TypedName Dtld.SchemaInterface
schemaInterfaceSchemaInterface = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.SchemaInterface")

-- | DSL accessor for the type field of hydra.ext.azure.dtld.SchemaInterface
schemaInterfaceType :: Typed.TypedTerm Dtld.SchemaInterface -> Typed.TypedTerm Dtld.SchemaInterfaceType
schemaInterfaceType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL injection for the array variant of hydra.ext.azure.dtld.SchemaInterfaceType
schemaInterfaceTypeArray :: Typed.TypedTerm Dtld.SchemaArray -> Typed.TypedTerm Dtld.SchemaInterfaceType
schemaInterfaceTypeArray x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterfaceType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "array"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the enum variant of hydra.ext.azure.dtld.SchemaInterfaceType
schemaInterfaceTypeEnum :: Typed.TypedTerm Dtld.SchemaEnum -> Typed.TypedTerm Dtld.SchemaInterfaceType
schemaInterfaceTypeEnum x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterfaceType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "enum"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the map variant of hydra.ext.azure.dtld.SchemaInterfaceType
schemaInterfaceTypeMap :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm Dtld.SchemaInterfaceType
schemaInterfaceTypeMap x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterfaceType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "map"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the object variant of hydra.ext.azure.dtld.SchemaInterfaceType
schemaInterfaceTypeObject :: Typed.TypedTerm Dtld.SchemaObject -> Typed.TypedTerm Dtld.SchemaInterfaceType
schemaInterfaceTypeObject x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterfaceType"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "object"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.ext.azure.dtld.SchemaInterfaceType
schemaInterfaceTypeSchemaInterfaceType :: Typed.TypedName Dtld.SchemaInterfaceType
schemaInterfaceTypeSchemaInterfaceType = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.SchemaInterfaceType")

-- | DSL updater for the comment field of hydra.ext.azure.dtld.SchemaInterface
schemaInterfaceWithComment :: Typed.TypedTerm Dtld.SchemaInterface -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaInterface
schemaInterfaceWithComment original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"),
      Model.recordFields = [
        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.azure.dtld.SchemaInterface"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the description field of hydra.ext.azure.dtld.SchemaInterface
schemaInterfaceWithDescription :: Typed.TypedTerm Dtld.SchemaInterface -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaInterface
schemaInterfaceWithDescription original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"),
      Model.recordFields = [
        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.azure.dtld.SchemaInterface"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the displayName field of hydra.ext.azure.dtld.SchemaInterface
schemaInterfaceWithDisplayName :: Typed.TypedTerm Dtld.SchemaInterface -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaInterface
schemaInterfaceWithDisplayName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"),
      Model.recordFields = [
        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.azure.dtld.SchemaInterface"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the id field of hydra.ext.azure.dtld.SchemaInterface
schemaInterfaceWithId :: Typed.TypedTerm Dtld.SchemaInterface -> Typed.TypedTerm Dtld.Dtmi -> Typed.TypedTerm Dtld.SchemaInterface
schemaInterfaceWithId original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.azure.dtld.SchemaInterface
schemaInterfaceWithType :: Typed.TypedTerm Dtld.SchemaInterface -> Typed.TypedTerm Dtld.SchemaInterfaceType -> Typed.TypedTerm Dtld.SchemaInterface
schemaInterfaceWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"),
      Model.recordFields = [
        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.azure.dtld.SchemaInterface"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaInterface"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.azure.dtld.SchemaMap
schemaMap :: Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm Dtld.MapKey -> Typed.TypedTerm Dtld.MapValue -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaMap
schemaMap type_ mapKey mapValue id comment description displayName =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "mapKey"),
          Model.fieldTerm = (Typed.unTypedTerm mapKey)},
        Model.Field {
          Model.fieldName = (Model.Name "mapValue"),
          Model.fieldTerm = (Typed.unTypedTerm mapValue)},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm id)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm comment)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm description)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm displayName)}]}))

-- | DSL accessor for the comment field of hydra.ext.azure.dtld.SchemaMap
schemaMapComment :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm (Maybe String)
schemaMapComment x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
        Model.projectionFieldName = (Model.Name "comment")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the description field of hydra.ext.azure.dtld.SchemaMap
schemaMapDescription :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm (Maybe String)
schemaMapDescription x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
        Model.projectionFieldName = (Model.Name "description")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.SchemaMap
schemaMapDisplayName :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm (Maybe String)
schemaMapDisplayName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
        Model.projectionFieldName = (Model.Name "displayName")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the id field of hydra.ext.azure.dtld.SchemaMap
schemaMapId :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm (Maybe Dtld.Dtmi)
schemaMapId x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
        Model.projectionFieldName = (Model.Name "id")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the mapKey field of hydra.ext.azure.dtld.SchemaMap
schemaMapMapKey :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm Dtld.MapKey
schemaMapMapKey x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
        Model.projectionFieldName = (Model.Name "mapKey")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the mapValue field of hydra.ext.azure.dtld.SchemaMap
schemaMapMapValue :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm Dtld.MapValue
schemaMapMapValue x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
        Model.projectionFieldName = (Model.Name "mapValue")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.azure.dtld.SchemaMap
schemaMapSchemaMap :: Typed.TypedName Dtld.SchemaMap
schemaMapSchemaMap = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.SchemaMap")

-- | DSL accessor for the type field of hydra.ext.azure.dtld.SchemaMap
schemaMapType :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm Dtld.Iri
schemaMapType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the comment field of hydra.ext.azure.dtld.SchemaMap
schemaMapWithComment :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaMap
schemaMapWithComment original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
      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.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "mapKey"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "mapKey")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "mapValue"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "mapValue")})),
            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.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the description field of hydra.ext.azure.dtld.SchemaMap
schemaMapWithDescription :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaMap
schemaMapWithDescription original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
      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.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "mapKey"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "mapKey")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "mapValue"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "mapValue")})),
            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.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the displayName field of hydra.ext.azure.dtld.SchemaMap
schemaMapWithDisplayName :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaMap
schemaMapWithDisplayName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
      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.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "mapKey"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "mapKey")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "mapValue"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "mapValue")})),
            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.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the id field of hydra.ext.azure.dtld.SchemaMap
schemaMapWithId :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm Dtld.SchemaMap
schemaMapWithId original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
      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.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "mapKey"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "mapKey")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "mapValue"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "mapValue")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the mapKey field of hydra.ext.azure.dtld.SchemaMap
schemaMapWithMapKey :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm Dtld.MapKey -> Typed.TypedTerm Dtld.SchemaMap
schemaMapWithMapKey original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
      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.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "mapKey"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "mapValue"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "mapValue")})),
            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.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the mapValue field of hydra.ext.azure.dtld.SchemaMap
schemaMapWithMapValue :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm Dtld.MapValue -> Typed.TypedTerm Dtld.SchemaMap
schemaMapWithMapValue original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
      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.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "mapKey"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "mapKey")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "mapValue"),
          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.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.azure.dtld.SchemaMap
schemaMapWithType :: Typed.TypedTerm Dtld.SchemaMap -> Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm Dtld.SchemaMap
schemaMapWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "mapKey"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "mapKey")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "mapValue"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "mapValue")})),
            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.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaMap"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.ext.azure.dtld.SchemaObject
schemaObject :: Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm (S.Set Dtld.Field) -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaObject
schemaObject type_ fields id comment description displayName =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "fields"),
          Model.fieldTerm = (Typed.unTypedTerm fields)},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm id)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm comment)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm description)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm displayName)}]}))

-- | DSL accessor for the comment field of hydra.ext.azure.dtld.SchemaObject
schemaObjectComment :: Typed.TypedTerm Dtld.SchemaObject -> Typed.TypedTerm (Maybe String)
schemaObjectComment x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
        Model.projectionFieldName = (Model.Name "comment")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the description field of hydra.ext.azure.dtld.SchemaObject
schemaObjectDescription :: Typed.TypedTerm Dtld.SchemaObject -> Typed.TypedTerm (Maybe String)
schemaObjectDescription x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
        Model.projectionFieldName = (Model.Name "description")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.SchemaObject
schemaObjectDisplayName :: Typed.TypedTerm Dtld.SchemaObject -> Typed.TypedTerm (Maybe String)
schemaObjectDisplayName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
        Model.projectionFieldName = (Model.Name "displayName")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the fields field of hydra.ext.azure.dtld.SchemaObject
schemaObjectFields :: Typed.TypedTerm Dtld.SchemaObject -> Typed.TypedTerm (S.Set Dtld.Field)
schemaObjectFields x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
        Model.projectionFieldName = (Model.Name "fields")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the id field of hydra.ext.azure.dtld.SchemaObject
schemaObjectId :: Typed.TypedTerm Dtld.SchemaObject -> Typed.TypedTerm (Maybe Dtld.Dtmi)
schemaObjectId x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
        Model.projectionFieldName = (Model.Name "id")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.azure.dtld.SchemaObject
schemaObjectSchemaObject :: Typed.TypedName Dtld.SchemaObject
schemaObjectSchemaObject = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.SchemaObject")

-- | DSL accessor for the type field of hydra.ext.azure.dtld.SchemaObject
schemaObjectType :: Typed.TypedTerm Dtld.SchemaObject -> Typed.TypedTerm Dtld.Iri
schemaObjectType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the comment field of hydra.ext.azure.dtld.SchemaObject
schemaObjectWithComment :: Typed.TypedTerm Dtld.SchemaObject -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaObject
schemaObjectWithComment original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
      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.azure.dtld.SchemaObject"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "fields"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
              Model.projectionFieldName = (Model.Name "fields")})),
            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.azure.dtld.SchemaObject"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the description field of hydra.ext.azure.dtld.SchemaObject
schemaObjectWithDescription :: Typed.TypedTerm Dtld.SchemaObject -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaObject
schemaObjectWithDescription original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
      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.azure.dtld.SchemaObject"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "fields"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
              Model.projectionFieldName = (Model.Name "fields")})),
            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.azure.dtld.SchemaObject"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the displayName field of hydra.ext.azure.dtld.SchemaObject
schemaObjectWithDisplayName :: Typed.TypedTerm Dtld.SchemaObject -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.SchemaObject
schemaObjectWithDisplayName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
      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.azure.dtld.SchemaObject"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "fields"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
              Model.projectionFieldName = (Model.Name "fields")})),
            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.azure.dtld.SchemaObject"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the fields field of hydra.ext.azure.dtld.SchemaObject
schemaObjectWithFields :: Typed.TypedTerm Dtld.SchemaObject -> Typed.TypedTerm (S.Set Dtld.Field) -> Typed.TypedTerm Dtld.SchemaObject
schemaObjectWithFields original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
      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.azure.dtld.SchemaObject"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "fields"),
          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.azure.dtld.SchemaObject"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the id field of hydra.ext.azure.dtld.SchemaObject
schemaObjectWithId :: Typed.TypedTerm Dtld.SchemaObject -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm Dtld.SchemaObject
schemaObjectWithId original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
      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.azure.dtld.SchemaObject"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "fields"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
              Model.projectionFieldName = (Model.Name "fields")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.azure.dtld.SchemaObject
schemaObjectWithType :: Typed.TypedTerm Dtld.SchemaObject -> Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm Dtld.SchemaObject
schemaObjectWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "fields"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
              Model.projectionFieldName = (Model.Name "fields")})),
            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.azure.dtld.SchemaObject"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaObject"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

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

-- | DSL injection for the boolean variant of hydra.ext.azure.dtld.SchemaPrimitive
schemaPrimitiveBoolean :: Typed.TypedTerm Dtld.SchemaPrimitive
schemaPrimitiveBoolean =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaPrimitive"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "boolean"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the date variant of hydra.ext.azure.dtld.SchemaPrimitive
schemaPrimitiveDate :: Typed.TypedTerm Dtld.SchemaPrimitive
schemaPrimitiveDate =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaPrimitive"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "date"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the dateTime variant of hydra.ext.azure.dtld.SchemaPrimitive
schemaPrimitiveDateTime :: Typed.TypedTerm Dtld.SchemaPrimitive
schemaPrimitiveDateTime =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaPrimitive"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "dateTime"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the double variant of hydra.ext.azure.dtld.SchemaPrimitive
schemaPrimitiveDouble :: Typed.TypedTerm Dtld.SchemaPrimitive
schemaPrimitiveDouble =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaPrimitive"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "double"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the duration variant of hydra.ext.azure.dtld.SchemaPrimitive
schemaPrimitiveDuration :: Typed.TypedTerm Dtld.SchemaPrimitive
schemaPrimitiveDuration =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaPrimitive"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "duration"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the float variant of hydra.ext.azure.dtld.SchemaPrimitive
schemaPrimitiveFloat :: Typed.TypedTerm Dtld.SchemaPrimitive
schemaPrimitiveFloat =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaPrimitive"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "float"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the integer variant of hydra.ext.azure.dtld.SchemaPrimitive
schemaPrimitiveInteger :: Typed.TypedTerm Dtld.SchemaPrimitive
schemaPrimitiveInteger =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaPrimitive"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "integer"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the long variant of hydra.ext.azure.dtld.SchemaPrimitive
schemaPrimitiveLong :: Typed.TypedTerm Dtld.SchemaPrimitive
schemaPrimitiveLong =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaPrimitive"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "long"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.ext.azure.dtld.SchemaPrimitive
schemaPrimitiveSchemaPrimitive :: Typed.TypedName Dtld.SchemaPrimitive
schemaPrimitiveSchemaPrimitive = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.SchemaPrimitive")

-- | DSL injection for the string variant of hydra.ext.azure.dtld.SchemaPrimitive
schemaPrimitiveString :: Typed.TypedTerm Dtld.SchemaPrimitive
schemaPrimitiveString =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaPrimitive"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "string"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the time variant of hydra.ext.azure.dtld.SchemaPrimitive
schemaPrimitiveTime :: Typed.TypedTerm Dtld.SchemaPrimitive
schemaPrimitiveTime =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.ext.azure.dtld.SchemaPrimitive"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "time"),
        Model.fieldTerm = Model.TermUnit}}))

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

-- | DSL constructor for hydra.ext.azure.dtld.Telemetry
telemetry :: Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm String -> Typed.TypedTerm Dtld.Schema -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm (Maybe Dtld.Unit) -> Typed.TypedTerm Dtld.Telemetry
telemetry type_ name schema id comment description displayName unit =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          Model.fieldTerm = (Typed.unTypedTerm type_)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Typed.unTypedTerm schema)},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm id)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm comment)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm description)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm displayName)},
        Model.Field {
          Model.fieldName = (Model.Name "unit"),
          Model.fieldTerm = (Typed.unTypedTerm unit)}]}))

-- | DSL accessor for the comment field of hydra.ext.azure.dtld.Telemetry
telemetryComment :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm (Maybe String)
telemetryComment x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
        Model.projectionFieldName = (Model.Name "comment")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the description field of hydra.ext.azure.dtld.Telemetry
telemetryDescription :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm (Maybe String)
telemetryDescription x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
        Model.projectionFieldName = (Model.Name "description")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the displayName field of hydra.ext.azure.dtld.Telemetry
telemetryDisplayName :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm (Maybe String)
telemetryDisplayName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
        Model.projectionFieldName = (Model.Name "displayName")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the id field of hydra.ext.azure.dtld.Telemetry
telemetryId :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm (Maybe Dtld.Dtmi)
telemetryId x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
        Model.projectionFieldName = (Model.Name "id")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the name field of hydra.ext.azure.dtld.Telemetry
telemetryName :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm String
telemetryName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

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

-- | DSL name token for hydra.ext.azure.dtld.Telemetry
telemetryTelemetry :: Typed.TypedName Dtld.Telemetry
telemetryTelemetry = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.Telemetry")

-- | DSL accessor for the type field of hydra.ext.azure.dtld.Telemetry
telemetryType :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm Dtld.Iri
telemetryType x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
        Model.projectionFieldName = (Model.Name "type")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the unit field of hydra.ext.azure.dtld.Telemetry
telemetryUnit :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm (Maybe Dtld.Unit)
telemetryUnit x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
        Model.projectionFieldName = (Model.Name "unit")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the comment field of hydra.ext.azure.dtld.Telemetry
telemetryWithComment :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Telemetry
telemetryWithComment original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
      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.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "unit"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "unit")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the description field of hydra.ext.azure.dtld.Telemetry
telemetryWithDescription :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Telemetry
telemetryWithDescription original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
      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.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "unit"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "unit")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the displayName field of hydra.ext.azure.dtld.Telemetry
telemetryWithDisplayName :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Dtld.Telemetry
telemetryWithDisplayName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
      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.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "unit"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "unit")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the id field of hydra.ext.azure.dtld.Telemetry
telemetryWithId :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm (Maybe Dtld.Dtmi) -> Typed.TypedTerm Dtld.Telemetry
telemetryWithId original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
      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.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "schema")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "id"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "unit"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "unit")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.ext.azure.dtld.Telemetry
telemetryWithName :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm String -> Typed.TypedTerm Dtld.Telemetry
telemetryWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
      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.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "type")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "unit"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "unit")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the schema field of hydra.ext.azure.dtld.Telemetry
telemetryWithSchema :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm Dtld.Schema -> Typed.TypedTerm Dtld.Telemetry
telemetryWithSchema original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
      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.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          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.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "unit"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "unit")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the type field of hydra.ext.azure.dtld.Telemetry
telemetryWithType :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm Dtld.Telemetry
telemetryWithType original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "type"),
          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.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "unit"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "unit")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the unit field of hydra.ext.azure.dtld.Telemetry
telemetryWithUnit :: Typed.TypedTerm Dtld.Telemetry -> Typed.TypedTerm (Maybe Dtld.Unit) -> Typed.TypedTerm Dtld.Telemetry
telemetryWithUnit original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
      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.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "type")})),
            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.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "schema"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "schema")})),
            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.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "id")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "comment"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "comment")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "displayName"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.ext.azure.dtld.Telemetry"),
              Model.projectionFieldName = (Model.Name "displayName")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "unit"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL accessor for the body of hydra.ext.azure.dtld.Dtmi
unDtmi :: Typed.TypedTerm Dtld.Dtmi -> Typed.TypedTerm String
unDtmi x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.azure.dtld.Dtmi")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.azure.dtld.Iri
unIri :: Typed.TypedTerm Dtld.Iri -> Typed.TypedTerm String
unIri x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.azure.dtld.Iri")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the body of hydra.ext.azure.dtld.Unit
unUnit :: Typed.TypedTerm Dtld.Unit -> Typed.TypedTerm ()
unUnit x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.ext.azure.dtld.Unit")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL constructor for the hydra.ext.azure.dtld.Unit wrapper
unit :: Typed.TypedTerm () -> Typed.TypedTerm Dtld.Unit
unit x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.ext.azure.dtld.Unit"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.ext.azure.dtld.Unit
unitUnit :: Typed.TypedName Dtld.Unit
unitUnit = Typed.TypedName (Model.Name "hydra.ext.azure.dtld.Unit")