hydra-rdf-0.18.0: src/main/haskell/Hydra/Rdf/Dsl/Shacl/Model.hs

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

-- | DSL functions for hydra.rdf.shacl.model

module Hydra.Rdf.Dsl.Shacl.Model where

import qualified Hydra.Core.Errors as Errors
import qualified Hydra.Core.Graph as Graph
import qualified Hydra.Core.Model as Model
import qualified Hydra.Core.Typed as Typed
import qualified Hydra.Rdf.Dsl.Syntax as DslSyntax
import qualified Hydra.Rdf.Shacl.Model as ShaclModel
import qualified Hydra.Rdf.Syntax as Syntax
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.rdf.shacl.model.Closed
closed :: Typed.TypedTerm Bool -> Typed.TypedTerm (Maybe (S.Set Syntax.Property)) -> Typed.TypedTerm ShaclModel.Closed
closed isClosed ignoredProperties =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.Closed"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "isClosed"),
          Model.fieldTerm = (Typed.unTypedTerm isClosed)},
        Model.Field {
          Model.fieldName = (Model.Name "ignoredProperties"),
          Model.fieldTerm = (Typed.unTypedTerm ignoredProperties)}]}))

-- | DSL name token for hydra.rdf.shacl.model.Closed
closedClosed :: Typed.TypedName ShaclModel.Closed
closedClosed = Typed.TypedName (Model.Name "hydra.rdf.shacl.model.Closed")

-- | DSL accessor for the ignoredProperties field of hydra.rdf.shacl.model.Closed
closedIgnoredProperties :: Typed.TypedTerm ShaclModel.Closed -> Typed.TypedTerm (Maybe (S.Set Syntax.Property))
closedIgnoredProperties x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.Closed"),
        Model.projectionFieldName = (Model.Name "ignoredProperties")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the isClosed field of hydra.rdf.shacl.model.Closed
closedIsClosed :: Typed.TypedTerm ShaclModel.Closed -> Typed.TypedTerm Bool
closedIsClosed x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.Closed"),
        Model.projectionFieldName = (Model.Name "isClosed")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the ignoredProperties field of hydra.rdf.shacl.model.Closed
closedWithIgnoredProperties :: Typed.TypedTerm ShaclModel.Closed -> Typed.TypedTerm (Maybe (S.Set Syntax.Property)) -> Typed.TypedTerm ShaclModel.Closed
closedWithIgnoredProperties original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.Closed"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "isClosed"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.Closed"),
              Model.projectionFieldName = (Model.Name "isClosed")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "ignoredProperties"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the isClosed field of hydra.rdf.shacl.model.Closed
closedWithIsClosed :: Typed.TypedTerm ShaclModel.Closed -> Typed.TypedTerm Bool -> Typed.TypedTerm ShaclModel.Closed
closedWithIsClosed original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.Closed"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "isClosed"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "ignoredProperties"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.Closed"),
              Model.projectionFieldName = (Model.Name "ignoredProperties")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL injection for the and variant of hydra.rdf.shacl.model.CommonConstraint
commonConstraintAnd :: Typed.TypedTerm (S.Set (ShaclModel.Reference ShaclModel.Shape)) -> Typed.TypedTerm ShaclModel.CommonConstraint
commonConstraintAnd x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "and"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the class variant of hydra.rdf.shacl.model.CommonConstraint
commonConstraintClass :: Typed.TypedTerm (S.Set Syntax.RdfsClass) -> Typed.TypedTerm ShaclModel.CommonConstraint
commonConstraintClass x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "class"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the closed variant of hydra.rdf.shacl.model.CommonConstraint
commonConstraintClosed :: Typed.TypedTerm ShaclModel.Closed -> Typed.TypedTerm ShaclModel.CommonConstraint
commonConstraintClosed x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "closed"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.rdf.shacl.model.CommonConstraint
commonConstraintCommonConstraint :: Typed.TypedName ShaclModel.CommonConstraint
commonConstraintCommonConstraint = Typed.TypedName (Model.Name "hydra.rdf.shacl.model.CommonConstraint")

-- | DSL injection for the datatype variant of hydra.rdf.shacl.model.CommonConstraint
commonConstraintDatatype :: Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm ShaclModel.CommonConstraint
commonConstraintDatatype x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "datatype"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the disjoint variant of hydra.rdf.shacl.model.CommonConstraint
commonConstraintDisjoint :: Typed.TypedTerm (S.Set Syntax.Property) -> Typed.TypedTerm ShaclModel.CommonConstraint
commonConstraintDisjoint x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "disjoint"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the equals variant of hydra.rdf.shacl.model.CommonConstraint
commonConstraintEquals :: Typed.TypedTerm (S.Set Syntax.Property) -> Typed.TypedTerm ShaclModel.CommonConstraint
commonConstraintEquals x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "equals"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the hasValue variant of hydra.rdf.shacl.model.CommonConstraint
commonConstraintHasValue :: Typed.TypedTerm (S.Set Syntax.Node) -> Typed.TypedTerm ShaclModel.CommonConstraint
commonConstraintHasValue x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "hasValue"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the in variant of hydra.rdf.shacl.model.CommonConstraint
commonConstraintIn :: Typed.TypedTerm [Syntax.Node] -> Typed.TypedTerm ShaclModel.CommonConstraint
commonConstraintIn x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "in"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the languageIn variant of hydra.rdf.shacl.model.CommonConstraint
commonConstraintLanguageIn :: Typed.TypedTerm (S.Set Syntax.LanguageTag) -> Typed.TypedTerm ShaclModel.CommonConstraint
commonConstraintLanguageIn x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "languageIn"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the maxExclusive variant of hydra.rdf.shacl.model.CommonConstraint
commonConstraintMaxExclusive :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm ShaclModel.CommonConstraint
commonConstraintMaxExclusive x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "maxExclusive"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the maxInclusive variant of hydra.rdf.shacl.model.CommonConstraint
commonConstraintMaxInclusive :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm ShaclModel.CommonConstraint
commonConstraintMaxInclusive x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "maxInclusive"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the maxLength variant of hydra.rdf.shacl.model.CommonConstraint
commonConstraintMaxLength :: Typed.TypedTerm Integer -> Typed.TypedTerm ShaclModel.CommonConstraint
commonConstraintMaxLength x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "maxLength"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the minExclusive variant of hydra.rdf.shacl.model.CommonConstraint
commonConstraintMinExclusive :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm ShaclModel.CommonConstraint
commonConstraintMinExclusive x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "minExclusive"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the minInclusive variant of hydra.rdf.shacl.model.CommonConstraint
commonConstraintMinInclusive :: Typed.TypedTerm Syntax.Literal -> Typed.TypedTerm ShaclModel.CommonConstraint
commonConstraintMinInclusive x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "minInclusive"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the minLength variant of hydra.rdf.shacl.model.CommonConstraint
commonConstraintMinLength :: Typed.TypedTerm Integer -> Typed.TypedTerm ShaclModel.CommonConstraint
commonConstraintMinLength x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "minLength"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the node variant of hydra.rdf.shacl.model.CommonConstraint
commonConstraintNode :: Typed.TypedTerm (S.Set (ShaclModel.Reference ShaclModel.NodeShape)) -> Typed.TypedTerm ShaclModel.CommonConstraint
commonConstraintNode x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "node"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the nodeKind variant of hydra.rdf.shacl.model.CommonConstraint
commonConstraintNodeKind :: Typed.TypedTerm ShaclModel.NodeKind -> Typed.TypedTerm ShaclModel.CommonConstraint
commonConstraintNodeKind x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "nodeKind"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the not variant of hydra.rdf.shacl.model.CommonConstraint
commonConstraintNot :: Typed.TypedTerm (S.Set (ShaclModel.Reference ShaclModel.Shape)) -> Typed.TypedTerm ShaclModel.CommonConstraint
commonConstraintNot x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "not"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the or variant of hydra.rdf.shacl.model.CommonConstraint
commonConstraintOr :: Typed.TypedTerm (S.Set (ShaclModel.Reference ShaclModel.Shape)) -> Typed.TypedTerm ShaclModel.CommonConstraint
commonConstraintOr x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "or"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the pattern variant of hydra.rdf.shacl.model.CommonConstraint
commonConstraintPattern :: Typed.TypedTerm ShaclModel.Pattern -> Typed.TypedTerm ShaclModel.CommonConstraint
commonConstraintPattern x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "pattern"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the property variant of hydra.rdf.shacl.model.CommonConstraint
commonConstraintProperty :: Typed.TypedTerm (S.Set (ShaclModel.Reference ShaclModel.PropertyShape)) -> Typed.TypedTerm ShaclModel.CommonConstraint
commonConstraintProperty x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "property"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the xone variant of hydra.rdf.shacl.model.CommonConstraint
commonConstraintXone :: Typed.TypedTerm (S.Set (ShaclModel.Reference ShaclModel.Shape)) -> Typed.TypedTerm ShaclModel.CommonConstraint
commonConstraintXone x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "xone"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL constructor for hydra.rdf.shacl.model.CommonProperties
commonProperties :: Typed.TypedTerm (S.Set ShaclModel.CommonConstraint) -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm Syntax.LangStrings -> Typed.TypedTerm ShaclModel.Severity -> Typed.TypedTerm (S.Set Syntax.RdfsClass) -> Typed.TypedTerm (S.Set Syntax.IriOrLiteral) -> Typed.TypedTerm (S.Set Syntax.Property) -> Typed.TypedTerm (S.Set Syntax.Property) -> Typed.TypedTerm ShaclModel.CommonProperties
commonProperties constraints deactivated message severity targetClass targetNode targetObjectsOf targetSubjectsOf =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Typed.unTypedTerm constraints)},
        Model.Field {
          Model.fieldName = (Model.Name "deactivated"),
          Model.fieldTerm = (Typed.unTypedTerm deactivated)},
        Model.Field {
          Model.fieldName = (Model.Name "message"),
          Model.fieldTerm = (Typed.unTypedTerm message)},
        Model.Field {
          Model.fieldName = (Model.Name "severity"),
          Model.fieldTerm = (Typed.unTypedTerm severity)},
        Model.Field {
          Model.fieldName = (Model.Name "targetClass"),
          Model.fieldTerm = (Typed.unTypedTerm targetClass)},
        Model.Field {
          Model.fieldName = (Model.Name "targetNode"),
          Model.fieldTerm = (Typed.unTypedTerm targetNode)},
        Model.Field {
          Model.fieldName = (Model.Name "targetObjectsOf"),
          Model.fieldTerm = (Typed.unTypedTerm targetObjectsOf)},
        Model.Field {
          Model.fieldName = (Model.Name "targetSubjectsOf"),
          Model.fieldTerm = (Typed.unTypedTerm targetSubjectsOf)}]}))

-- | DSL name token for hydra.rdf.shacl.model.CommonProperties
commonPropertiesCommonProperties :: Typed.TypedName ShaclModel.CommonProperties
commonPropertiesCommonProperties = Typed.TypedName (Model.Name "hydra.rdf.shacl.model.CommonProperties")

-- | DSL accessor for the constraints field of hydra.rdf.shacl.model.CommonProperties
commonPropertiesConstraints :: Typed.TypedTerm ShaclModel.CommonProperties -> Typed.TypedTerm (S.Set ShaclModel.CommonConstraint)
commonPropertiesConstraints x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
        Model.projectionFieldName = (Model.Name "constraints")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the deactivated field of hydra.rdf.shacl.model.CommonProperties
commonPropertiesDeactivated :: Typed.TypedTerm ShaclModel.CommonProperties -> Typed.TypedTerm (Maybe Bool)
commonPropertiesDeactivated x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
        Model.projectionFieldName = (Model.Name "deactivated")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the message field of hydra.rdf.shacl.model.CommonProperties
commonPropertiesMessage :: Typed.TypedTerm ShaclModel.CommonProperties -> Typed.TypedTerm Syntax.LangStrings
commonPropertiesMessage x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
        Model.projectionFieldName = (Model.Name "message")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the severity field of hydra.rdf.shacl.model.CommonProperties
commonPropertiesSeverity :: Typed.TypedTerm ShaclModel.CommonProperties -> Typed.TypedTerm ShaclModel.Severity
commonPropertiesSeverity x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
        Model.projectionFieldName = (Model.Name "severity")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the targetClass field of hydra.rdf.shacl.model.CommonProperties
commonPropertiesTargetClass :: Typed.TypedTerm ShaclModel.CommonProperties -> Typed.TypedTerm (S.Set Syntax.RdfsClass)
commonPropertiesTargetClass x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
        Model.projectionFieldName = (Model.Name "targetClass")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the targetNode field of hydra.rdf.shacl.model.CommonProperties
commonPropertiesTargetNode :: Typed.TypedTerm ShaclModel.CommonProperties -> Typed.TypedTerm (S.Set Syntax.IriOrLiteral)
commonPropertiesTargetNode x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
        Model.projectionFieldName = (Model.Name "targetNode")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the targetObjectsOf field of hydra.rdf.shacl.model.CommonProperties
commonPropertiesTargetObjectsOf :: Typed.TypedTerm ShaclModel.CommonProperties -> Typed.TypedTerm (S.Set Syntax.Property)
commonPropertiesTargetObjectsOf x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
        Model.projectionFieldName = (Model.Name "targetObjectsOf")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the targetSubjectsOf field of hydra.rdf.shacl.model.CommonProperties
commonPropertiesTargetSubjectsOf :: Typed.TypedTerm ShaclModel.CommonProperties -> Typed.TypedTerm (S.Set Syntax.Property)
commonPropertiesTargetSubjectsOf x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
        Model.projectionFieldName = (Model.Name "targetSubjectsOf")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the constraints field of hydra.rdf.shacl.model.CommonProperties
commonPropertiesWithConstraints :: Typed.TypedTerm ShaclModel.CommonProperties -> Typed.TypedTerm (S.Set ShaclModel.CommonConstraint) -> Typed.TypedTerm ShaclModel.CommonProperties
commonPropertiesWithConstraints original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "deactivated"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "deactivated")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "message"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "message")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "severity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "severity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "targetClass"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "targetClass")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "targetNode"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "targetNode")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "targetObjectsOf"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "targetObjectsOf")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "targetSubjectsOf"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "targetSubjectsOf")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the deactivated field of hydra.rdf.shacl.model.CommonProperties
commonPropertiesWithDeactivated :: Typed.TypedTerm ShaclModel.CommonProperties -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm ShaclModel.CommonProperties
commonPropertiesWithDeactivated original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "deactivated"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "message"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "message")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "severity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "severity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "targetClass"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "targetClass")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "targetNode"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "targetNode")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "targetObjectsOf"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "targetObjectsOf")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "targetSubjectsOf"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "targetSubjectsOf")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the message field of hydra.rdf.shacl.model.CommonProperties
commonPropertiesWithMessage :: Typed.TypedTerm ShaclModel.CommonProperties -> Typed.TypedTerm Syntax.LangStrings -> Typed.TypedTerm ShaclModel.CommonProperties
commonPropertiesWithMessage original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "deactivated"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "deactivated")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "message"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "severity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "severity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "targetClass"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "targetClass")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "targetNode"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "targetNode")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "targetObjectsOf"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "targetObjectsOf")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "targetSubjectsOf"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "targetSubjectsOf")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the severity field of hydra.rdf.shacl.model.CommonProperties
commonPropertiesWithSeverity :: Typed.TypedTerm ShaclModel.CommonProperties -> Typed.TypedTerm ShaclModel.Severity -> Typed.TypedTerm ShaclModel.CommonProperties
commonPropertiesWithSeverity original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "deactivated"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "deactivated")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "message"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "message")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "severity"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "targetClass"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "targetClass")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "targetNode"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "targetNode")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "targetObjectsOf"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "targetObjectsOf")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "targetSubjectsOf"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "targetSubjectsOf")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the targetClass field of hydra.rdf.shacl.model.CommonProperties
commonPropertiesWithTargetClass :: Typed.TypedTerm ShaclModel.CommonProperties -> Typed.TypedTerm (S.Set Syntax.RdfsClass) -> Typed.TypedTerm ShaclModel.CommonProperties
commonPropertiesWithTargetClass original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "deactivated"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "deactivated")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "message"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "message")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "severity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "severity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "targetClass"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "targetNode"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "targetNode")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "targetObjectsOf"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "targetObjectsOf")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "targetSubjectsOf"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "targetSubjectsOf")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the targetNode field of hydra.rdf.shacl.model.CommonProperties
commonPropertiesWithTargetNode :: Typed.TypedTerm ShaclModel.CommonProperties -> Typed.TypedTerm (S.Set Syntax.IriOrLiteral) -> Typed.TypedTerm ShaclModel.CommonProperties
commonPropertiesWithTargetNode original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "deactivated"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "deactivated")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "message"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "message")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "severity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "severity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "targetClass"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "targetClass")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "targetNode"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "targetObjectsOf"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "targetObjectsOf")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "targetSubjectsOf"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "targetSubjectsOf")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the targetObjectsOf field of hydra.rdf.shacl.model.CommonProperties
commonPropertiesWithTargetObjectsOf :: Typed.TypedTerm ShaclModel.CommonProperties -> Typed.TypedTerm (S.Set Syntax.Property) -> Typed.TypedTerm ShaclModel.CommonProperties
commonPropertiesWithTargetObjectsOf original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "deactivated"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "deactivated")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "message"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "message")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "severity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "severity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "targetClass"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "targetClass")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "targetNode"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "targetNode")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "targetObjectsOf"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "targetSubjectsOf"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "targetSubjectsOf")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the targetSubjectsOf field of hydra.rdf.shacl.model.CommonProperties
commonPropertiesWithTargetSubjectsOf :: Typed.TypedTerm ShaclModel.CommonProperties -> Typed.TypedTerm (S.Set Syntax.Property) -> Typed.TypedTerm ShaclModel.CommonProperties
commonPropertiesWithTargetSubjectsOf original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "deactivated"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "deactivated")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "message"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "message")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "severity"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "severity")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "targetClass"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "targetClass")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "targetNode"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "targetNode")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "targetObjectsOf"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.CommonProperties"),
              Model.projectionFieldName = (Model.Name "targetObjectsOf")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "targetSubjectsOf"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL composition builder for the decoder of hydra.rdf.shacl.model.Definition
decodeDefinition :: Typed.TypedTerm (Graph.Graph -> Model.Term -> Either Errors.DecodingError a) -> Typed.TypedTerm (Graph.Graph -> Model.Term -> Either Errors.DecodingError (ShaclModel.Definition a))
decodeDefinition a =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.rdf.decode.shacl.model.definition")),
      Model.applicationArgument = (Typed.unTypedTerm a)}))

-- | DSL composition builder for the decoder of hydra.rdf.shacl.model.Reference
decodeReference :: Typed.TypedTerm (Graph.Graph -> Model.Term -> Either Errors.DecodingError a) -> Typed.TypedTerm (Graph.Graph -> Model.Term -> Either Errors.DecodingError (ShaclModel.Reference a))
decodeReference a =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.rdf.decode.shacl.model.reference")),
      Model.applicationArgument = (Typed.unTypedTerm a)}))

-- | DSL constructor for hydra.rdf.shacl.model.Definition
definition :: Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm a -> Typed.TypedTerm (ShaclModel.Definition a)
definition iri target =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.Definition"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "iri"),
          Model.fieldTerm = (Typed.unTypedTerm iri)},
        Model.Field {
          Model.fieldName = (Model.Name "target"),
          Model.fieldTerm = (Typed.unTypedTerm target)}]}))

-- | DSL name token for hydra.rdf.shacl.model.Definition
definitionDefinition :: Typed.TypedName (ShaclModel.Definition a)
definitionDefinition = Typed.TypedName (Model.Name "hydra.rdf.shacl.model.Definition")

-- | DSL accessor for the iri field of hydra.rdf.shacl.model.Definition
definitionIri :: Typed.TypedTerm (ShaclModel.Definition a) -> Typed.TypedTerm Syntax.Iri
definitionIri x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.Definition"),
        Model.projectionFieldName = (Model.Name "iri")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the target field of hydra.rdf.shacl.model.Definition
definitionTarget :: Typed.TypedTerm (ShaclModel.Definition a) -> Typed.TypedTerm a
definitionTarget x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.Definition"),
        Model.projectionFieldName = (Model.Name "target")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the iri field of hydra.rdf.shacl.model.Definition
definitionWithIri :: Typed.TypedTerm (ShaclModel.Definition a) -> Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm (ShaclModel.Definition a)
definitionWithIri original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.Definition"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "iri"),
          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.rdf.shacl.model.Definition"),
              Model.projectionFieldName = (Model.Name "target")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the target field of hydra.rdf.shacl.model.Definition
definitionWithTarget :: Typed.TypedTerm (ShaclModel.Definition a) -> Typed.TypedTerm a -> Typed.TypedTerm (ShaclModel.Definition a)
definitionWithTarget original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.Definition"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "iri"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.Definition"),
              Model.projectionFieldName = (Model.Name "iri")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "target"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL composition builder for the encoder of hydra.rdf.shacl.model.Definition
encodeDefinition :: Typed.TypedTerm (a -> Model.Term) -> Typed.TypedTerm (ShaclModel.Definition a -> Model.Term)
encodeDefinition a =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.rdf.encode.shacl.model.definition")),
      Model.applicationArgument = (Typed.unTypedTerm a)}))

-- | DSL composition builder for the encoder of hydra.rdf.shacl.model.Reference
encodeReference :: Typed.TypedTerm (a -> Model.Term) -> Typed.TypedTerm (ShaclModel.Reference a -> Model.Term)
encodeReference a =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermVariable (Model.Name "hydra.rdf.encode.shacl.model.reference")),
      Model.applicationArgument = (Typed.unTypedTerm a)}))

-- | DSL injection for the blankNode variant of hydra.rdf.shacl.model.NodeKind
nodeKindBlankNode :: Typed.TypedTerm ShaclModel.NodeKind
nodeKindBlankNode =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.NodeKind"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "blankNode"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the blankNodeOrIri variant of hydra.rdf.shacl.model.NodeKind
nodeKindBlankNodeOrIri :: Typed.TypedTerm ShaclModel.NodeKind
nodeKindBlankNodeOrIri =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.NodeKind"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "blankNodeOrIri"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the blankNodeOrLiteral variant of hydra.rdf.shacl.model.NodeKind
nodeKindBlankNodeOrLiteral :: Typed.TypedTerm ShaclModel.NodeKind
nodeKindBlankNodeOrLiteral =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.NodeKind"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "blankNodeOrLiteral"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the iri variant of hydra.rdf.shacl.model.NodeKind
nodeKindIri :: Typed.TypedTerm ShaclModel.NodeKind
nodeKindIri =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.NodeKind"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "iri"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the iriOrLiteral variant of hydra.rdf.shacl.model.NodeKind
nodeKindIriOrLiteral :: Typed.TypedTerm ShaclModel.NodeKind
nodeKindIriOrLiteral =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.NodeKind"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "iriOrLiteral"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the literal variant of hydra.rdf.shacl.model.NodeKind
nodeKindLiteral :: Typed.TypedTerm ShaclModel.NodeKind
nodeKindLiteral =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.NodeKind"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "literal"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.rdf.shacl.model.NodeKind
nodeKindNodeKind :: Typed.TypedName ShaclModel.NodeKind
nodeKindNodeKind = Typed.TypedName (Model.Name "hydra.rdf.shacl.model.NodeKind")

-- | DSL constructor for hydra.rdf.shacl.model.NodeShape
nodeShape :: Typed.TypedTerm ShaclModel.CommonProperties -> Typed.TypedTerm ShaclModel.NodeShape
nodeShape common =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.NodeShape"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "common"),
          Model.fieldTerm = (Typed.unTypedTerm common)}]}))

-- | DSL accessor for the common field of hydra.rdf.shacl.model.NodeShape
nodeShapeCommon :: Typed.TypedTerm ShaclModel.NodeShape -> Typed.TypedTerm ShaclModel.CommonProperties
nodeShapeCommon x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.NodeShape"),
        Model.projectionFieldName = (Model.Name "common")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.rdf.shacl.model.NodeShape
nodeShapeNodeShape :: Typed.TypedName ShaclModel.NodeShape
nodeShapeNodeShape = Typed.TypedName (Model.Name "hydra.rdf.shacl.model.NodeShape")

-- | DSL updater for the common field of hydra.rdf.shacl.model.NodeShape
nodeShapeWithCommon :: Typed.TypedTerm ShaclModel.NodeShape -> Typed.TypedTerm ShaclModel.CommonProperties -> Typed.TypedTerm ShaclModel.NodeShape
nodeShapeWithCommon original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.NodeShape"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "common"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.rdf.shacl.model.Pattern
pattern :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm ShaclModel.Pattern
pattern regex flags =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.Pattern"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "regex"),
          Model.fieldTerm = (Typed.unTypedTerm regex)},
        Model.Field {
          Model.fieldName = (Model.Name "flags"),
          Model.fieldTerm = (Typed.unTypedTerm flags)}]}))

-- | DSL accessor for the flags field of hydra.rdf.shacl.model.Pattern
patternFlags :: Typed.TypedTerm ShaclModel.Pattern -> Typed.TypedTerm (Maybe String)
patternFlags x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.Pattern"),
        Model.projectionFieldName = (Model.Name "flags")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.rdf.shacl.model.Pattern
patternPattern :: Typed.TypedName ShaclModel.Pattern
patternPattern = Typed.TypedName (Model.Name "hydra.rdf.shacl.model.Pattern")

-- | DSL accessor for the regex field of hydra.rdf.shacl.model.Pattern
patternRegex :: Typed.TypedTerm ShaclModel.Pattern -> Typed.TypedTerm String
patternRegex x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.Pattern"),
        Model.projectionFieldName = (Model.Name "regex")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the flags field of hydra.rdf.shacl.model.Pattern
patternWithFlags :: Typed.TypedTerm ShaclModel.Pattern -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm ShaclModel.Pattern
patternWithFlags original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.Pattern"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "regex"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.Pattern"),
              Model.projectionFieldName = (Model.Name "regex")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "flags"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL updater for the regex field of hydra.rdf.shacl.model.Pattern
patternWithRegex :: Typed.TypedTerm ShaclModel.Pattern -> Typed.TypedTerm String -> Typed.TypedTerm ShaclModel.Pattern
patternWithRegex original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.Pattern"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "regex"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "flags"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.Pattern"),
              Model.projectionFieldName = (Model.Name "flags")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL constructor for hydra.rdf.shacl.model.PropertyShape
propertyShape :: Typed.TypedTerm ShaclModel.CommonProperties -> Typed.TypedTerm (S.Set ShaclModel.PropertyShapeConstraint) -> Typed.TypedTerm (Maybe Syntax.Node) -> Typed.TypedTerm Syntax.LangStrings -> Typed.TypedTerm Syntax.LangStrings -> Typed.TypedTerm (Maybe Integer) -> Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm ShaclModel.PropertyShape
propertyShape common constraints defaultValue description name order path =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "common"),
          Model.fieldTerm = (Typed.unTypedTerm common)},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Typed.unTypedTerm constraints)},
        Model.Field {
          Model.fieldName = (Model.Name "defaultValue"),
          Model.fieldTerm = (Typed.unTypedTerm defaultValue)},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          Model.fieldTerm = (Typed.unTypedTerm description)},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm name)},
        Model.Field {
          Model.fieldName = (Model.Name "order"),
          Model.fieldTerm = (Typed.unTypedTerm order)},
        Model.Field {
          Model.fieldName = (Model.Name "path"),
          Model.fieldTerm = (Typed.unTypedTerm path)}]}))

-- | DSL accessor for the common field of hydra.rdf.shacl.model.PropertyShape
propertyShapeCommon :: Typed.TypedTerm ShaclModel.PropertyShape -> Typed.TypedTerm ShaclModel.CommonProperties
propertyShapeCommon x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
        Model.projectionFieldName = (Model.Name "common")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL injection for the lessThan variant of hydra.rdf.shacl.model.PropertyShapeConstraint
propertyShapeConstraintLessThan :: Typed.TypedTerm (S.Set Syntax.Property) -> Typed.TypedTerm ShaclModel.PropertyShapeConstraint
propertyShapeConstraintLessThan x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShapeConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "lessThan"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the lessThanOrEquals variant of hydra.rdf.shacl.model.PropertyShapeConstraint
propertyShapeConstraintLessThanOrEquals :: Typed.TypedTerm (S.Set Syntax.Property) -> Typed.TypedTerm ShaclModel.PropertyShapeConstraint
propertyShapeConstraintLessThanOrEquals x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShapeConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "lessThanOrEquals"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the maxCount variant of hydra.rdf.shacl.model.PropertyShapeConstraint
propertyShapeConstraintMaxCount :: Typed.TypedTerm Integer -> Typed.TypedTerm ShaclModel.PropertyShapeConstraint
propertyShapeConstraintMaxCount x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShapeConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "maxCount"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the minCount variant of hydra.rdf.shacl.model.PropertyShapeConstraint
propertyShapeConstraintMinCount :: Typed.TypedTerm Integer -> Typed.TypedTerm ShaclModel.PropertyShapeConstraint
propertyShapeConstraintMinCount x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShapeConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "minCount"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.rdf.shacl.model.PropertyShapeConstraint
propertyShapeConstraintPropertyShapeConstraint :: Typed.TypedName ShaclModel.PropertyShapeConstraint
propertyShapeConstraintPropertyShapeConstraint =
    Typed.TypedName (Model.Name "hydra.rdf.shacl.model.PropertyShapeConstraint")

-- | DSL injection for the qualifiedValueShape variant of hydra.rdf.shacl.model.PropertyShapeConstraint
propertyShapeConstraintQualifiedValueShape :: Typed.TypedTerm ShaclModel.QualifiedValueShape -> Typed.TypedTerm ShaclModel.PropertyShapeConstraint
propertyShapeConstraintQualifiedValueShape x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShapeConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "qualifiedValueShape"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the uniqueLang variant of hydra.rdf.shacl.model.PropertyShapeConstraint
propertyShapeConstraintUniqueLang :: Typed.TypedTerm Bool -> Typed.TypedTerm ShaclModel.PropertyShapeConstraint
propertyShapeConstraintUniqueLang x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShapeConstraint"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "uniqueLang"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL accessor for the constraints field of hydra.rdf.shacl.model.PropertyShape
propertyShapeConstraints :: Typed.TypedTerm ShaclModel.PropertyShape -> Typed.TypedTerm (S.Set ShaclModel.PropertyShapeConstraint)
propertyShapeConstraints x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
        Model.projectionFieldName = (Model.Name "constraints")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the defaultValue field of hydra.rdf.shacl.model.PropertyShape
propertyShapeDefaultValue :: Typed.TypedTerm ShaclModel.PropertyShape -> Typed.TypedTerm (Maybe Syntax.Node)
propertyShapeDefaultValue x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
        Model.projectionFieldName = (Model.Name "defaultValue")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the description field of hydra.rdf.shacl.model.PropertyShape
propertyShapeDescription :: Typed.TypedTerm ShaclModel.PropertyShape -> Typed.TypedTerm Syntax.LangStrings
propertyShapeDescription x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
        Model.projectionFieldName = (Model.Name "description")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the name field of hydra.rdf.shacl.model.PropertyShape
propertyShapeName :: Typed.TypedTerm ShaclModel.PropertyShape -> Typed.TypedTerm Syntax.LangStrings
propertyShapeName x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
        Model.projectionFieldName = (Model.Name "name")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the order field of hydra.rdf.shacl.model.PropertyShape
propertyShapeOrder :: Typed.TypedTerm ShaclModel.PropertyShape -> Typed.TypedTerm (Maybe Integer)
propertyShapeOrder x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
        Model.projectionFieldName = (Model.Name "order")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the path field of hydra.rdf.shacl.model.PropertyShape
propertyShapePath :: Typed.TypedTerm ShaclModel.PropertyShape -> Typed.TypedTerm Syntax.Iri
propertyShapePath x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
        Model.projectionFieldName = (Model.Name "path")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.rdf.shacl.model.PropertyShape
propertyShapePropertyShape :: Typed.TypedName ShaclModel.PropertyShape
propertyShapePropertyShape = Typed.TypedName (Model.Name "hydra.rdf.shacl.model.PropertyShape")

-- | DSL updater for the common field of hydra.rdf.shacl.model.PropertyShape
propertyShapeWithCommon :: Typed.TypedTerm ShaclModel.PropertyShape -> Typed.TypedTerm ShaclModel.CommonProperties -> Typed.TypedTerm ShaclModel.PropertyShape
propertyShapeWithCommon original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "common"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "defaultValue"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "defaultValue")})),
            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.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "description")})),
            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.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "order"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "order")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "path"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "path")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the constraints field of hydra.rdf.shacl.model.PropertyShape
propertyShapeWithConstraints :: Typed.TypedTerm ShaclModel.PropertyShape -> Typed.TypedTerm (S.Set ShaclModel.PropertyShapeConstraint) -> Typed.TypedTerm ShaclModel.PropertyShape
propertyShapeWithConstraints original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "common"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "common")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "defaultValue"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "defaultValue")})),
            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.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "description")})),
            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.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "order"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "order")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "path"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "path")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the defaultValue field of hydra.rdf.shacl.model.PropertyShape
propertyShapeWithDefaultValue :: Typed.TypedTerm ShaclModel.PropertyShape -> Typed.TypedTerm (Maybe Syntax.Node) -> Typed.TypedTerm ShaclModel.PropertyShape
propertyShapeWithDefaultValue original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "common"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "common")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "defaultValue"),
          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.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "description")})),
            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.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "order"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "order")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "path"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "path")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the description field of hydra.rdf.shacl.model.PropertyShape
propertyShapeWithDescription :: Typed.TypedTerm ShaclModel.PropertyShape -> Typed.TypedTerm Syntax.LangStrings -> Typed.TypedTerm ShaclModel.PropertyShape
propertyShapeWithDescription original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "common"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "common")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "defaultValue"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "defaultValue")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "description"),
          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.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "order"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "order")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "path"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "path")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the name field of hydra.rdf.shacl.model.PropertyShape
propertyShapeWithName :: Typed.TypedTerm ShaclModel.PropertyShape -> Typed.TypedTerm Syntax.LangStrings -> Typed.TypedTerm ShaclModel.PropertyShape
propertyShapeWithName original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "common"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "common")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "defaultValue"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "defaultValue")})),
            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.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "description")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "name"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "order"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "order")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "path"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "path")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the order field of hydra.rdf.shacl.model.PropertyShape
propertyShapeWithOrder :: Typed.TypedTerm ShaclModel.PropertyShape -> Typed.TypedTerm (Maybe Integer) -> Typed.TypedTerm ShaclModel.PropertyShape
propertyShapeWithOrder original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "common"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "common")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "defaultValue"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "defaultValue")})),
            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.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "description")})),
            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.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "order"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "path"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "path")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the path field of hydra.rdf.shacl.model.PropertyShape
propertyShapeWithPath :: Typed.TypedTerm ShaclModel.PropertyShape -> Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm ShaclModel.PropertyShape
propertyShapeWithPath original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "common"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "common")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "constraints"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "constraints")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "defaultValue"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "defaultValue")})),
            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.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "description")})),
            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.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "name")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "order"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.PropertyShape"),
              Model.projectionFieldName = (Model.Name "order")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "path"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL constructor for hydra.rdf.shacl.model.QualifiedValueShape
qualifiedValueShape :: Typed.TypedTerm (ShaclModel.Reference ShaclModel.Shape) -> Typed.TypedTerm Integer -> Typed.TypedTerm Integer -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm ShaclModel.QualifiedValueShape
qualifiedValueShape qualifiedValueShape qualifiedMaxCount qualifiedMinCount qualifiedValueShapesDisjoint =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.QualifiedValueShape"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "qualifiedValueShape"),
          Model.fieldTerm = (Typed.unTypedTerm qualifiedValueShape)},
        Model.Field {
          Model.fieldName = (Model.Name "qualifiedMaxCount"),
          Model.fieldTerm = (Typed.unTypedTerm qualifiedMaxCount)},
        Model.Field {
          Model.fieldName = (Model.Name "qualifiedMinCount"),
          Model.fieldTerm = (Typed.unTypedTerm qualifiedMinCount)},
        Model.Field {
          Model.fieldName = (Model.Name "qualifiedValueShapesDisjoint"),
          Model.fieldTerm = (Typed.unTypedTerm qualifiedValueShapesDisjoint)}]}))

-- | DSL accessor for the qualifiedMaxCount field of hydra.rdf.shacl.model.QualifiedValueShape
qualifiedValueShapeQualifiedMaxCount :: Typed.TypedTerm ShaclModel.QualifiedValueShape -> Typed.TypedTerm Integer
qualifiedValueShapeQualifiedMaxCount x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.QualifiedValueShape"),
        Model.projectionFieldName = (Model.Name "qualifiedMaxCount")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the qualifiedMinCount field of hydra.rdf.shacl.model.QualifiedValueShape
qualifiedValueShapeQualifiedMinCount :: Typed.TypedTerm ShaclModel.QualifiedValueShape -> Typed.TypedTerm Integer
qualifiedValueShapeQualifiedMinCount x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.QualifiedValueShape"),
        Model.projectionFieldName = (Model.Name "qualifiedMinCount")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.rdf.shacl.model.QualifiedValueShape
qualifiedValueShapeQualifiedValueShape :: Typed.TypedName ShaclModel.QualifiedValueShape
qualifiedValueShapeQualifiedValueShape = Typed.TypedName (Model.Name "hydra.rdf.shacl.model.QualifiedValueShape")

-- | DSL accessor for the qualifiedValueShape field of hydra.rdf.shacl.model.QualifiedValueShape
qualifiedValueShapeQualifiedValueShape2 :: Typed.TypedTerm ShaclModel.QualifiedValueShape -> Typed.TypedTerm (ShaclModel.Reference ShaclModel.Shape)
qualifiedValueShapeQualifiedValueShape2 x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.QualifiedValueShape"),
        Model.projectionFieldName = (Model.Name "qualifiedValueShape")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL accessor for the qualifiedValueShapesDisjoint field of hydra.rdf.shacl.model.QualifiedValueShape
qualifiedValueShapeQualifiedValueShapesDisjoint :: Typed.TypedTerm ShaclModel.QualifiedValueShape -> Typed.TypedTerm (Maybe Bool)
qualifiedValueShapeQualifiedValueShapesDisjoint x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermProject (Model.Projection {
        Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.QualifiedValueShape"),
        Model.projectionFieldName = (Model.Name "qualifiedValueShapesDisjoint")})),
      Model.applicationArgument = (Typed.unTypedTerm x)}))

-- | DSL updater for the qualifiedMaxCount field of hydra.rdf.shacl.model.QualifiedValueShape
qualifiedValueShapeWithQualifiedMaxCount :: Typed.TypedTerm ShaclModel.QualifiedValueShape -> Typed.TypedTerm Integer -> Typed.TypedTerm ShaclModel.QualifiedValueShape
qualifiedValueShapeWithQualifiedMaxCount original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.QualifiedValueShape"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "qualifiedValueShape"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.QualifiedValueShape"),
              Model.projectionFieldName = (Model.Name "qualifiedValueShape")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "qualifiedMaxCount"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "qualifiedMinCount"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.QualifiedValueShape"),
              Model.projectionFieldName = (Model.Name "qualifiedMinCount")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "qualifiedValueShapesDisjoint"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.QualifiedValueShape"),
              Model.projectionFieldName = (Model.Name "qualifiedValueShapesDisjoint")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the qualifiedMinCount field of hydra.rdf.shacl.model.QualifiedValueShape
qualifiedValueShapeWithQualifiedMinCount :: Typed.TypedTerm ShaclModel.QualifiedValueShape -> Typed.TypedTerm Integer -> Typed.TypedTerm ShaclModel.QualifiedValueShape
qualifiedValueShapeWithQualifiedMinCount original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.QualifiedValueShape"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "qualifiedValueShape"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.QualifiedValueShape"),
              Model.projectionFieldName = (Model.Name "qualifiedValueShape")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "qualifiedMaxCount"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.QualifiedValueShape"),
              Model.projectionFieldName = (Model.Name "qualifiedMaxCount")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "qualifiedMinCount"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "qualifiedValueShapesDisjoint"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.QualifiedValueShape"),
              Model.projectionFieldName = (Model.Name "qualifiedValueShapesDisjoint")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the qualifiedValueShape field of hydra.rdf.shacl.model.QualifiedValueShape
qualifiedValueShapeWithQualifiedValueShape :: Typed.TypedTerm ShaclModel.QualifiedValueShape -> Typed.TypedTerm (ShaclModel.Reference ShaclModel.Shape) -> Typed.TypedTerm ShaclModel.QualifiedValueShape
qualifiedValueShapeWithQualifiedValueShape original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.QualifiedValueShape"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "qualifiedValueShape"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)},
        Model.Field {
          Model.fieldName = (Model.Name "qualifiedMaxCount"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.QualifiedValueShape"),
              Model.projectionFieldName = (Model.Name "qualifiedMaxCount")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "qualifiedMinCount"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.QualifiedValueShape"),
              Model.projectionFieldName = (Model.Name "qualifiedMinCount")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "qualifiedValueShapesDisjoint"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.QualifiedValueShape"),
              Model.projectionFieldName = (Model.Name "qualifiedValueShapesDisjoint")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))}]}))

-- | DSL updater for the qualifiedValueShapesDisjoint field of hydra.rdf.shacl.model.QualifiedValueShape
qualifiedValueShapeWithQualifiedValueShapesDisjoint :: Typed.TypedTerm ShaclModel.QualifiedValueShape -> Typed.TypedTerm (Maybe Bool) -> Typed.TypedTerm ShaclModel.QualifiedValueShape
qualifiedValueShapeWithQualifiedValueShapesDisjoint original newVal =
    Typed.TypedTerm (Model.TermRecord (Model.Record {
      Model.recordTypeName = (Model.Name "hydra.rdf.shacl.model.QualifiedValueShape"),
      Model.recordFields = [
        Model.Field {
          Model.fieldName = (Model.Name "qualifiedValueShape"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.QualifiedValueShape"),
              Model.projectionFieldName = (Model.Name "qualifiedValueShape")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "qualifiedMaxCount"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.QualifiedValueShape"),
              Model.projectionFieldName = (Model.Name "qualifiedMaxCount")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "qualifiedMinCount"),
          Model.fieldTerm = (Model.TermApplication (Model.Application {
            Model.applicationFunction = (Model.TermProject (Model.Projection {
              Model.projectionTypeName = (Model.Name "hydra.rdf.shacl.model.QualifiedValueShape"),
              Model.projectionFieldName = (Model.Name "qualifiedMinCount")})),
            Model.applicationArgument = (Typed.unTypedTerm original)}))},
        Model.Field {
          Model.fieldName = (Model.Name "qualifiedValueShapesDisjoint"),
          Model.fieldTerm = (Typed.unTypedTerm newVal)}]}))

-- | DSL injection for the anonymous variant of hydra.rdf.shacl.model.Reference
referenceAnonymous :: Typed.TypedTerm a -> Typed.TypedTerm (ShaclModel.Reference a)
referenceAnonymous x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.Reference"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "anonymous"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the definition variant of hydra.rdf.shacl.model.Reference
referenceDefinition :: Typed.TypedTerm (ShaclModel.Definition a) -> Typed.TypedTerm (ShaclModel.Reference a)
referenceDefinition x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.Reference"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "definition"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the named variant of hydra.rdf.shacl.model.Reference
referenceNamed :: Typed.TypedTerm Syntax.Iri -> Typed.TypedTerm (ShaclModel.Reference a)
referenceNamed x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.Reference"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "named"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.rdf.shacl.model.Reference
referenceReference :: Typed.TypedName (ShaclModel.Reference a)
referenceReference = Typed.TypedName (Model.Name "hydra.rdf.shacl.model.Reference")

-- | DSL injection for the info variant of hydra.rdf.shacl.model.Severity
severityInfo :: Typed.TypedTerm ShaclModel.Severity
severityInfo =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.Severity"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "info"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL name token for hydra.rdf.shacl.model.Severity
severitySeverity :: Typed.TypedName ShaclModel.Severity
severitySeverity = Typed.TypedName (Model.Name "hydra.rdf.shacl.model.Severity")

-- | DSL injection for the violation variant of hydra.rdf.shacl.model.Severity
severityViolation :: Typed.TypedTerm ShaclModel.Severity
severityViolation =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.Severity"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "violation"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the warning variant of hydra.rdf.shacl.model.Severity
severityWarning :: Typed.TypedTerm ShaclModel.Severity
severityWarning =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.Severity"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "warning"),
        Model.fieldTerm = Model.TermUnit}}))

-- | DSL injection for the node variant of hydra.rdf.shacl.model.Shape
shapeNode :: Typed.TypedTerm ShaclModel.NodeShape -> Typed.TypedTerm ShaclModel.Shape
shapeNode x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.Shape"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "node"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL injection for the property variant of hydra.rdf.shacl.model.Shape
shapeProperty :: Typed.TypedTerm ShaclModel.PropertyShape -> Typed.TypedTerm ShaclModel.Shape
shapeProperty x =
    Typed.TypedTerm (Model.TermInject (Model.Injection {
      Model.injectionTypeName = (Model.Name "hydra.rdf.shacl.model.Shape"),
      Model.injectionField = Model.Field {
        Model.fieldName = (Model.Name "property"),
        Model.fieldTerm = (Typed.unTypedTerm x)}}))

-- | DSL name token for hydra.rdf.shacl.model.Shape
shapeShape :: Typed.TypedName ShaclModel.Shape
shapeShape = Typed.TypedName (Model.Name "hydra.rdf.shacl.model.Shape")

-- | DSL constructor for the hydra.rdf.shacl.model.ShapesGraph wrapper
shapesGraph :: Typed.TypedTerm (S.Set (ShaclModel.Definition ShaclModel.Shape)) -> Typed.TypedTerm ShaclModel.ShapesGraph
shapesGraph x =
    Typed.TypedTerm (Model.TermWrap (Model.WrappedTerm {
      Model.wrappedTermTypeName = (Model.Name "hydra.rdf.shacl.model.ShapesGraph"),
      Model.wrappedTermBody = (Typed.unTypedTerm x)}))

-- | DSL name token for hydra.rdf.shacl.model.ShapesGraph
shapesGraphShapesGraph :: Typed.TypedName ShaclModel.ShapesGraph
shapesGraphShapesGraph = Typed.TypedName (Model.Name "hydra.rdf.shacl.model.ShapesGraph")

-- | DSL accessor for the body of hydra.rdf.shacl.model.ShapesGraph
unShapesGraph :: Typed.TypedTerm ShaclModel.ShapesGraph -> Typed.TypedTerm (S.Set (ShaclModel.Definition ShaclModel.Shape))
unShapesGraph x =
    Typed.TypedTerm (Model.TermApplication (Model.Application {
      Model.applicationFunction = (Model.TermUnwrap (Model.Name "hydra.rdf.shacl.model.ShapesGraph")),
      Model.applicationArgument = (Typed.unTypedTerm x)}))