@shaclmate/compiler 4.0.93 → 4.0.95

package/dist/input/input.shaclmate.js

@@ -1,7 +1,7 @@
 import dataFactory from "@rdfx/data-factory";
 import { LiteralFactory } from "@rdfx/literal";
 import { PropertyPath as RdfxResourcePropertyPath, Resource, } from "@rdfx/resource";
-import { NTriplesIdentifier, NTriplesTerm } from "@rdfx/string";
+import { NTriplesIdentifier } from "@rdfx/string";
 import { Either, Left, Maybe, Right } from "purify-ts";
 function $bigIntFromRdfResourceValues(values, options) {
     return $termLikeFromRdfResourceValues(values, options).chain((values) => values.chainMap((value) => options.schema.in
@@ -24,6 +24,7 @@ function $compactRecord(record) {
         return definedProperties;
     }, {});
 }
+const $convertToBigInt = (value) => Either.encase(() => BigInt(value));
 function $convertToIdentifier(value, defaultNamespace) {
     switch (typeof value) {
         case "object":
@@ -134,7 +135,7 @@ function $defaultValueFromRdfResourceValues(itemFromRdfResourceValues) {
 }
 function $ensureRdfResourceType(resource, types, options) {
     return resource
-        .value($RdfVocabularies.rdf.type, options)
+        .value($rdf_type, options)
         .chain((actualRdfTypeValue) => actualRdfTypeValue.toIri())
         .chain((actualRdfType) => {
         // Check the expected type and its known subtypes
@@ -151,15 +152,18 @@ function $floatFromRdfResourceValues(values, options) {
         ? value.toFloat(options.schema.in)
         : value.toFloat()));
 }
-function $identifierFromRdfResourceValues(values, options) {
-    return $termLikeFromRdfResourceValues(values, options).chain((values) => values.chainMap((value) => value.toIdentifier()));
-}
+const $identifierFromRdfResourceValues = (values, options) => $termLikeFromRdfResourceValues(values, options).chain((values) => values.chainMap((value) => value.toIdentifier()));
 function $identityConversionFunction(value, _defaultNamespace) {
     return Either.of(value);
 }
 function $identityValidationFunction(_schema, value) {
     return Either.of(value);
 }
+function $intFromRdfResourceValues(values, options) {
+    return $termLikeFromRdfResourceValues(values, options).chain((values) => values.chainMap((value) => options.schema.in
+        ? value.toInt(options.schema.in)
+        : value.toInt()));
+}
 function $iriFromRdfResourceValues(values, options) {
     return $termLikeFromRdfResourceValues(values, options).chain((values) => values.chainMap((value) => options.schema.in
         ? value.toIri(options.schema.in)
@@ -176,9 +180,7 @@ function $listFromRdfResourceValues(itemFromRdfResourceValues) {
         .map((valueLists) => valueLists.map((valueList) => valueList.toArray())); // Convert inner Resource.Values to arrays
 }
 const $literalFactory = new LiteralFactory({ dataFactory: dataFactory });
-function $literalFromRdfResourceValues(values, options) {
-    return $termLikeFromRdfResourceValues(values, options).chain((values) => values.chainMap((value) => value.toLiteral(options.schema.in)));
-}
+const $literalFromRdfResourceValues = (values, options) => $termLikeFromRdfResourceValues(values, options).chain((values) => values.chainMap((value) => value.toLiteral(options.schema.in)));
 function $maybeFromRdfResourceValues(itemFromRdfResourceValues) {
     return (values, options) => itemFromRdfResourceValues(values, {
         ...options,
@@ -220,51 +222,20 @@ export var $PropertyPath;
     $PropertyPath.schema = {};
     $PropertyPath.$toString = RdfxResourcePropertyPath.toString;
 })($PropertyPath || ($PropertyPath = {}));
+const $rdf_subject = dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#subject");
+const $rdf_type = dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#type");
 function $rdfResourceIdentifierValues(resource) {
     return new Resource.Value({
         dataFactory: dataFactory,
         focusResource: resource,
-        propertyPath: $RdfVocabularies.rdf.subject,
+        propertyPath: $rdf_subject,
         term: resource.identifier,
     }).toValues();
 }
-var $RdfVocabularies;
-(function ($RdfVocabularies) {
-    $RdfVocabularies.rdf = {
-        first: dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#first"),
-        langString: dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#langString"),
-        nil: dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#nil"),
-        rest: dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#rest"),
-        subject: dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#subject"),
-        type: dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"),
-    };
-    $RdfVocabularies.rdfs = {
-        subClassOf: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#subClassOf"),
-    };
-    $RdfVocabularies.xsd = {
-        boolean: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#boolean"),
-        byte: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#byte"),
-        date: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#date"),
-        dateTime: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#dateTime"),
-        dateTimeStamp: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#dateTimeStamp"),
-        decimal: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#decimal"),
-        double: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#double"),
-        float: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#float"),
-        int: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#int"),
-        integer: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#integer"),
-        long: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#long"),
-        negativeInteger: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#negativeInteger"),
-        nonNegativeInteger: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#nonNegativeInteger"),
-        nonPositiveInteger: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#nonPositiveInteger"),
-        positiveInteger: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#positiveInteger"),
-        short: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#short"),
-        string: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#string"),
-        unsignedByte: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#unsignedByte"),
-        unsignedInt: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#unsignedInt"),
-        unsignedLong: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#unsignedLong"),
-        unsignedShort: dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#unsignedShort"),
-    };
-})($RdfVocabularies || ($RdfVocabularies = {}));
+const $rdfs_comment = dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment");
+const $rdfs_isDefinedBy = dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#isDefinedBy");
+const $rdfs_label = dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label");
+const $rdfs_subClassOf = dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#subClassOf");
 function $sequenceRecord(record) {
     const result = {};
     for (const key of globalThis.Object.keys(record)) {
@@ -399,17 +370,25 @@ function $wrap_FromRdfResourceFunction(_fromRdfResourceFunction) {
         });
     };
 }
+const $xsd_boolean = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#boolean");
+const $xsd_double = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#double");
+const $xsd_int = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#int");
+const $xsd_integer = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#integer");
+const $xsd_string = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#string");
 export var NodeShape;
 (function (NodeShape) {
-    NodeShape._fromRdfResource = (resource, options) => (!options.ignoreRdfType
-        ? $ensureRdfResourceType(resource, [NodeShape.schema.properties.$rdfType.fromRdfType], { graph: options.graph })
-        : Right(true)).chain((_rdfTypeCheck) => $sequenceRecord({
+    NodeShape._fromRdfResource = (resource, options) => $sequenceRecord({
         $identifier: $identifierFromRdfResourceValues($rdfResourceIdentifierValues(resource), {
             ...options,
             focusResource: resource,
-            propertyPath: $RdfVocabularies.rdf.subject,
+            propertyPath: $rdf_subject,
             schema: NodeShape.schema.properties.$identifier.type,
         }).chain((values) => values.head()),
+        $rdfType: !options.ignoreRdfType
+            ? $ensureRdfResourceType(resource, [NodeShape.schema.properties.$rdfType.fromRdfType], {
+                graph: options.graph,
+            })
+            : Right(true),
         and: $shaclPropertyFromRdf({
             ...options,
             focusResource: resource,
@@ -711,60 +690,56 @@ export var NodeShape;
             propertySchema: NodeShape.schema.properties.xone,
             typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues($identifierFromRdfResourceValues)),
         }),
-    }).chain((properties) => NodeShape.create(properties)));
+    }).chain((properties) => NodeShape.create(properties));
     NodeShape.$toString = (_nodeShape) => `NodeShape(${JSON.stringify(NodeShape.toStringRecord(_nodeShape))})`;
-    NodeShape.create = (parameters) => $sequenceRecord({
-        $identifier: $convertToIdentifierProperty(parameters?.$identifier, parameters?.$defaultNamespace),
-        and: $convertToMaybe($convertToList($convertToIdentifier))(parameters?.and, parameters?.$defaultNamespace).chain((value) => $validateMaybe($validateArray($identityValidationFunction))(NodeShape.schema.properties.and.type, value)),
-        classes: $convertToScalarSet($convertToIri)(parameters?.classes, parameters?.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(NodeShape.schema.properties.classes.type, value)),
-        closed: $convertToMaybe($identityConversionFunction)(parameters?.closed, parameters?.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.closed.type, value)),
-        comment: $convertToMaybe($identityConversionFunction)(parameters?.comment, parameters?.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.comment.type, value)),
-        datatype: $convertToMaybe($convertToIri)(parameters?.datatype, parameters?.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.datatype.type, value)),
-        deactivated: $convertToMaybe($identityConversionFunction)(parameters?.deactivated, parameters?.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.deactivated.type, value)),
-        discriminantValue: $convertToMaybe($identityConversionFunction)(parameters?.discriminantValue, parameters?.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.discriminantValue.type, value)),
-        extern: $convertToMaybe($identityConversionFunction)(parameters?.extern, parameters?.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.extern.type, value)),
-        flags: $convertToMaybe($identityConversionFunction)(parameters?.flags, parameters?.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.flags.type, value)),
-        fromRdfType: $convertToMaybe($convertToIri)(parameters?.fromRdfType, parameters?.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.fromRdfType.type, value)),
-        hasValues: $convertToScalarSet($identityConversionFunction)(parameters?.hasValues, parameters?.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(NodeShape.schema.properties.hasValues.type, value)),
-        ignore: $convertWithDefaultValue($identityConversionFunction, false)(parameters?.ignore, parameters?.$defaultNamespace),
-        ignoredProperties: $convertToMaybe($convertToList($convertToIri))(parameters?.ignoredProperties, parameters?.$defaultNamespace).chain((value) => $validateMaybe($validateArray($identityValidationFunction))(NodeShape.schema.properties.ignoredProperties.type, value)),
-        in_: $convertToMaybe($convertToList($identityConversionFunction))(parameters?.in_, parameters?.$defaultNamespace).chain((value) => $validateMaybe($validateArray($identityValidationFunction))(NodeShape.schema.properties.in_.type, value)),
-        isDefinedBy: $convertToMaybe($convertToIdentifier)(parameters?.isDefinedBy, parameters?.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.isDefinedBy.type, value)),
-        label: $convertToMaybe($identityConversionFunction)(parameters?.label, parameters?.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.label.type, value)),
-        languageIn: $convertToMaybe($convertToList($identityConversionFunction))(parameters?.languageIn, parameters?.$defaultNamespace).chain((value) => $validateMaybe($validateArray($identityValidationFunction))(NodeShape.schema.properties.languageIn.type, value)),
-        maxExclusive: $convertToMaybe($convertToLiteral)(parameters?.maxExclusive, parameters?.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.maxExclusive.type, value)),
-        maxInclusive: $convertToMaybe($convertToLiteral)(parameters?.maxInclusive, parameters?.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.maxInclusive.type, value)),
-        maxLength: $convertToMaybe($identityConversionFunction)(parameters?.maxLength, parameters?.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.maxLength.type, value)),
-        message: $convertToMaybe($identityConversionFunction)(parameters?.message, parameters?.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.message.type, value)),
-        minExclusive: $convertToMaybe($convertToLiteral)(parameters?.minExclusive, parameters?.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.minExclusive.type, value)),
-        minInclusive: $convertToMaybe($convertToLiteral)(parameters?.minInclusive, parameters?.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.minInclusive.type, value)),
-        minLength: $convertToMaybe($identityConversionFunction)(parameters?.minLength, parameters?.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.minLength.type, value)),
-        mutable: $convertToMaybe($identityConversionFunction)(parameters?.mutable, parameters?.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.mutable.type, value)),
-        node: $convertToMaybe($convertToIdentifier)(parameters?.node, parameters?.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.node.type, value)),
-        nodeKind: $convertToMaybe(($convertToInIri))(parameters?.nodeKind, parameters?.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.nodeKind.type, value)),
-        not: $convertToScalarSet($convertToIdentifier)(parameters?.not, parameters?.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(NodeShape.schema.properties.not.type, value)),
-        or: $convertToMaybe($convertToList($convertToIdentifier))(parameters?.or, parameters?.$defaultNamespace).chain((value) => $validateMaybe($validateArray($identityValidationFunction))(NodeShape.schema.properties.or.type, value)),
-        pattern: $convertToMaybe($identityConversionFunction)(parameters?.pattern, parameters?.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.pattern.type, value)),
-        properties: $convertToScalarSet($convertToIdentifier)(parameters?.properties, parameters?.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(NodeShape.schema.properties.properties.type, value)),
-        rdfType: $convertToMaybe($convertToIri)(parameters?.rdfType, parameters?.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.rdfType.type, value)),
-        severity: $convertToMaybe(($convertToInIri))(parameters?.severity, parameters?.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.severity.type, value)),
-        shaclmateName: $convertToMaybe($identityConversionFunction)(parameters?.shaclmateName, parameters?.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.shaclmateName.type, value)),
-        subClassOf: $convertToScalarSet($convertToIri)(parameters?.subClassOf, parameters?.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(NodeShape.schema.properties.subClassOf.type, value)),
-        targetClasses: $convertToScalarSet($convertToIri)(parameters?.targetClasses, parameters?.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(NodeShape.schema.properties.targetClasses.type, value)),
-        targetNodes: $convertToScalarSet($identityConversionFunction)(parameters?.targetNodes, parameters?.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(NodeShape.schema.properties.targetNodes.type, value)),
-        targetObjectsOf: $convertToScalarSet($convertToIri)(parameters?.targetObjectsOf, parameters?.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(NodeShape.schema.properties.targetObjectsOf.type, value)),
-        targetSubjectsOf: $convertToScalarSet($convertToIri)(parameters?.targetSubjectsOf, parameters?.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(NodeShape.schema.properties.targetSubjectsOf.type, value)),
-        toRdfTypes: $convertToScalarSet($convertToIri)(parameters?.toRdfTypes, parameters?.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(NodeShape.schema.properties.toRdfTypes.type, value)),
-        tsImports: $convertToScalarSet($identityConversionFunction)(parameters?.tsImports, parameters?.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(NodeShape.schema.properties.tsImports.type, value)),
-        types: $convertToScalarSet($convertToIri)(parameters?.types, parameters?.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(NodeShape.schema.properties.types.type, value)),
-        xone: $convertToMaybe($convertToList($convertToIdentifier))(parameters?.xone, parameters?.$defaultNamespace).chain((value) => $validateMaybe($validateArray($identityValidationFunction))(NodeShape.schema.properties.xone.type, value)),
-    })
-        .map((properties) => ({ ...properties, $type: "NodeShape" }))
-        .map((object) => $monkeyPatchObject(object, { $toString: NodeShape.$toString }));
-    function createUnsafe(parameters) {
-        return NodeShape.create(parameters).unsafeCoerce();
-    }
-    NodeShape.createUnsafe = createUnsafe;
+    NodeShape.create = (parameters = {}) => $sequenceRecord({
+        $identifier: $convertToIdentifierProperty(parameters.$identifier, parameters.$defaultNamespace),
+        $type: Right("NodeShape"),
+        and: $convertToMaybe($convertToList($convertToIdentifier))(parameters.and, parameters.$defaultNamespace).chain((value) => $validateMaybe($validateArray($identityValidationFunction))(NodeShape.schema.properties.and.type, value)),
+        classes: $convertToScalarSet($convertToIri)(parameters.classes, parameters.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(NodeShape.schema.properties.classes.type, value)),
+        closed: $convertToMaybe($identityConversionFunction)(parameters.closed, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.closed.type, value)),
+        comment: $convertToMaybe($identityConversionFunction)(parameters.comment, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.comment.type, value)),
+        datatype: $convertToMaybe($convertToIri)(parameters.datatype, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.datatype.type, value)),
+        deactivated: $convertToMaybe($identityConversionFunction)(parameters.deactivated, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.deactivated.type, value)),
+        discriminantValue: $convertToMaybe($identityConversionFunction)(parameters.discriminantValue, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.discriminantValue.type, value)),
+        extern: $convertToMaybe($identityConversionFunction)(parameters.extern, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.extern.type, value)),
+        flags: $convertToMaybe($identityConversionFunction)(parameters.flags, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.flags.type, value)),
+        fromRdfType: $convertToMaybe($convertToIri)(parameters.fromRdfType, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.fromRdfType.type, value)),
+        hasValues: $convertToScalarSet($identityConversionFunction)(parameters.hasValues, parameters.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(NodeShape.schema.properties.hasValues.type, value)),
+        ignore: $convertWithDefaultValue($identityConversionFunction, false)(parameters.ignore, parameters.$defaultNamespace),
+        ignoredProperties: $convertToMaybe($convertToList($convertToIri))(parameters.ignoredProperties, parameters.$defaultNamespace).chain((value) => $validateMaybe($validateArray($identityValidationFunction))(NodeShape.schema.properties.ignoredProperties.type, value)),
+        in_: $convertToMaybe($convertToList($identityConversionFunction))(parameters.in_, parameters.$defaultNamespace).chain((value) => $validateMaybe($validateArray($identityValidationFunction))(NodeShape.schema.properties.in_.type, value)),
+        isDefinedBy: $convertToMaybe($convertToIdentifier)(parameters.isDefinedBy, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.isDefinedBy.type, value)),
+        label: $convertToMaybe($identityConversionFunction)(parameters.label, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.label.type, value)),
+        languageIn: $convertToMaybe($convertToList($identityConversionFunction))(parameters.languageIn, parameters.$defaultNamespace).chain((value) => $validateMaybe($validateArray($identityValidationFunction))(NodeShape.schema.properties.languageIn.type, value)),
+        maxExclusive: $convertToMaybe($convertToLiteral)(parameters.maxExclusive, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.maxExclusive.type, value)),
+        maxInclusive: $convertToMaybe($convertToLiteral)(parameters.maxInclusive, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.maxInclusive.type, value)),
+        maxLength: $convertToMaybe($convertToBigInt)(parameters.maxLength, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.maxLength.type, value)),
+        message: $convertToMaybe($identityConversionFunction)(parameters.message, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.message.type, value)),
+        minExclusive: $convertToMaybe($convertToLiteral)(parameters.minExclusive, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.minExclusive.type, value)),
+        minInclusive: $convertToMaybe($convertToLiteral)(parameters.minInclusive, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.minInclusive.type, value)),
+        minLength: $convertToMaybe($convertToBigInt)(parameters.minLength, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.minLength.type, value)),
+        mutable: $convertToMaybe($identityConversionFunction)(parameters.mutable, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.mutable.type, value)),
+        node: $convertToMaybe($convertToIdentifier)(parameters.node, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.node.type, value)),
+        nodeKind: $convertToMaybe(($convertToInIri))(parameters.nodeKind, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.nodeKind.type, value)),
+        not: $convertToScalarSet($convertToIdentifier)(parameters.not, parameters.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(NodeShape.schema.properties.not.type, value)),
+        or: $convertToMaybe($convertToList($convertToIdentifier))(parameters.or, parameters.$defaultNamespace).chain((value) => $validateMaybe($validateArray($identityValidationFunction))(NodeShape.schema.properties.or.type, value)),
+        pattern: $convertToMaybe($identityConversionFunction)(parameters.pattern, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.pattern.type, value)),
+        properties: $convertToScalarSet($convertToIdentifier)(parameters.properties, parameters.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(NodeShape.schema.properties.properties.type, value)),
+        rdfType: $convertToMaybe($convertToIri)(parameters.rdfType, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.rdfType.type, value)),
+        severity: $convertToMaybe(($convertToInIri))(parameters.severity, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.severity.type, value)),
+        shaclmateName: $convertToMaybe($identityConversionFunction)(parameters.shaclmateName, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.shaclmateName.type, value)),
+        subClassOf: $convertToScalarSet($convertToIri)(parameters.subClassOf, parameters.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(NodeShape.schema.properties.subClassOf.type, value)),
+        targetClasses: $convertToScalarSet($convertToIri)(parameters.targetClasses, parameters.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(NodeShape.schema.properties.targetClasses.type, value)),
+        targetNodes: $convertToScalarSet($identityConversionFunction)(parameters.targetNodes, parameters.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(NodeShape.schema.properties.targetNodes.type, value)),
+        targetObjectsOf: $convertToScalarSet($convertToIri)(parameters.targetObjectsOf, parameters.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(NodeShape.schema.properties.targetObjectsOf.type, value)),
+        targetSubjectsOf: $convertToScalarSet($convertToIri)(parameters.targetSubjectsOf, parameters.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(NodeShape.schema.properties.targetSubjectsOf.type, value)),
+        toRdfTypes: $convertToScalarSet($convertToIri)(parameters.toRdfTypes, parameters.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(NodeShape.schema.properties.toRdfTypes.type, value)),
+        tsImports: $convertToScalarSet($identityConversionFunction)(parameters.tsImports, parameters.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(NodeShape.schema.properties.tsImports.type, value)),
+        types: $convertToScalarSet($convertToIri)(parameters.types, parameters.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(NodeShape.schema.properties.types.type, value)),
+        xone: $convertToMaybe($convertToList($convertToIdentifier))(parameters.xone, parameters.$defaultNamespace).chain((value) => $validateMaybe($validateArray($identityValidationFunction))(NodeShape.schema.properties.xone.type, value)),
+    }).map((object) => $monkeyPatchObject(object, { $toString: NodeShape.$toString }));
+    NodeShape.createUnsafe = (parameters) => NodeShape.create(parameters).unsafeCoerce();
     NodeShape.fromRdfResource = $wrap_FromRdfResourceFunction(NodeShape._fromRdfResource);
     NodeShape.fromRdfResourceValues = (values, options) => values.chainMap((value) => value
         .toResource()
@@ -772,7 +747,6 @@ export var NodeShape;
     let Identifier;
     (function (Identifier) {
         Identifier.parse = $parseIdentifier;
-        Identifier.stringify = NTriplesTerm.stringify;
     })(Identifier = NodeShape.Identifier || (NodeShape.Identifier = {}));
     NodeShape.isNodeShape = (object) => object.$type === "NodeShape";
     NodeShape.schema = {
@@ -788,7 +762,6 @@ export var NodeShape;
                     dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"),
                 ],
             },
-            $type: { kind: "Discriminant", value: "NodeShape" },
             and: {
                 kind: "Shacl",
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#and"),
@@ -810,15 +783,15 @@ export var NodeShape;
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#closed"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "Boolean" },
+                    itemType: { kind: "Boolean", datatype: $xsd_boolean },
                 },
             },
             comment: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
+                path: $rdfs_comment,
                 type: {
                     kind: "Option",
-                    itemType: { kind: "String" },
+                    itemType: { kind: "String", datatype: $xsd_string },
                 },
             },
             datatype: {
@@ -831,7 +804,7 @@ export var NodeShape;
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#deactivated"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "Boolean" },
+                    itemType: { kind: "Boolean", datatype: $xsd_boolean },
                 },
             },
             discriminantValue: {
@@ -839,7 +812,7 @@ export var NodeShape;
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#discriminantValue"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "String" },
+                    itemType: { kind: "String", datatype: $xsd_string },
                 },
             },
             extern: {
@@ -847,7 +820,7 @@ export var NodeShape;
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#extern"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "Boolean" },
+                    itemType: { kind: "Boolean", datatype: $xsd_boolean },
                 },
             },
             flags: {
@@ -855,7 +828,7 @@ export var NodeShape;
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#flags"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "String" },
+                    itemType: { kind: "String", datatype: $xsd_string },
                 },
             },
             fromRdfType: {
@@ -876,8 +849,8 @@ export var NodeShape;
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#ignore"),
                 type: {
                     kind: "DefaultValue",
-                    itemType: { kind: "Boolean" },
-                    defaultValue: dataFactory.literal("false", $RdfVocabularies.xsd.boolean),
+                    itemType: { kind: "Boolean", datatype: $xsd_boolean },
+                    defaultValue: dataFactory.literal("false", $xsd_boolean),
                 },
             },
             ignoredProperties: {
@@ -907,7 +880,7 @@ export var NodeShape;
             },
             isDefinedBy: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#isDefinedBy"),
+                path: $rdfs_isDefinedBy,
                 type: {
                     kind: "Option",
                     itemType: { kind: "Identifier" },
@@ -915,10 +888,10 @@ export var NodeShape;
             },
             label: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
+                path: $rdfs_label,
                 type: {
                     kind: "Option",
-                    itemType: { kind: "String" },
+                    itemType: { kind: "String", datatype: $xsd_string },
                 },
             },
             languageIn: {
@@ -928,7 +901,7 @@ export var NodeShape;
                     kind: "Option",
                     itemType: {
                         kind: "List",
-                        itemType: { kind: "String" },
+                        itemType: { kind: "String", datatype: $xsd_string },
                     },
                 },
             },
@@ -953,7 +926,7 @@ export var NodeShape;
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxLength"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "BigInt" },
+                    itemType: { kind: "BigInt", datatype: $xsd_integer },
                 },
             },
             message: {
@@ -961,7 +934,7 @@ export var NodeShape;
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#message"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "String" },
+                    itemType: { kind: "String", datatype: $xsd_string },
                 },
             },
             minExclusive: {
@@ -980,28 +953,694 @@ export var NodeShape;
                     itemType: { kind: "Literal" },
                 },
             },
-            minLength: {
+            minLength: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minLength"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "BigInt", datatype: $xsd_integer },
+                },
+            },
+            mutable: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#mutable"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Boolean", datatype: $xsd_boolean },
+                },
+            },
+            node: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#node"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Identifier" },
+                },
+            },
+            nodeKind: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#nodeKind"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "Iri",
+                        in: [
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNode"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNodeOrIRI"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNodeOrLiteral"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#IRI"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#IRIOrLiteral"),
+                            dataFactory.namedNode("http://www.w3.org/ns/shacl#Literal"),
+                        ],
+                    },
+                },
+            },
+            not: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#not"),
+                type: {
+                    kind: "Set",
+                    itemType: { kind: "Identifier" },
+                },
+            },
+            or: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#or"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "Identifier" },
+                    },
+                },
+            },
+            pattern: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#pattern"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String", datatype: $xsd_string },
+                },
+            },
+            properties: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#property"),
+                type: {
+                    kind: "Set",
+                    itemType: { kind: "Identifier" },
+                },
+            },
+            rdfType: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#rdfType"),
+                type: { kind: "Option", itemType: { kind: "Iri" } },
+            },
+            severity: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#severity"),
+                get type() {
+                    return {
+                        kind: "Option",
+                        get itemType() {
+                            return Severity.schema;
+                        },
+                    };
+                },
+            },
+            shaclmateName: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#name"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String", datatype: $xsd_string },
+                },
+            },
+            subClassOf: {
+                kind: "Shacl",
+                path: $rdfs_subClassOf,
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            targetClasses: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetClass"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            targetNodes: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetNode"),
+                type: {
+                    kind: "Set",
+                    itemType: { kind: "Term", types: ["NamedNode", "Literal"] },
+                },
+            },
+            targetObjectsOf: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetObjectsOf"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            targetSubjectsOf: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetSubjectsOf"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            toRdfTypes: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#toRdfType"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            tsImports: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsImport"),
+                type: {
+                    kind: "Set",
+                    itemType: { kind: "String", datatype: $xsd_string },
+                },
+            },
+            types: {
+                kind: "Shacl",
+                path: $rdf_type,
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            xone: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#xone"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "Identifier" },
+                    },
+                },
+            },
+        },
+    };
+    NodeShape.toStringRecord = (_nodeShape) => $compactRecord({
+        $identifier: _nodeShape.$identifier().toString(),
+        label: _nodeShape.label.map((item) => item.toString()).extract(),
+        shaclmateName: _nodeShape.shaclmateName
+            .map((item) => item.toString())
+            .extract(),
+    });
+})(NodeShape || (NodeShape = {}));
+export var Ontology;
+(function (Ontology) {
+    Ontology._fromRdfResource = (resource, options) => $sequenceRecord({
+        $identifier: $identifierFromRdfResourceValues($rdfResourceIdentifierValues(resource), {
+            ...options,
+            focusResource: resource,
+            propertyPath: $rdf_subject,
+            schema: Ontology.schema.properties.$identifier.type,
+        }).chain((values) => values.head()),
+        $rdfType: !options.ignoreRdfType
+            ? $ensureRdfResourceType(resource, [Ontology.schema.properties.$rdfType.fromRdfType], {
+                graph: options.graph,
+            })
+            : Right(true),
+        comment: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.comment,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        label: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.label,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+    }).chain((properties) => Ontology.create(properties));
+    Ontology.$toString = (_ontology) => `Ontology(${JSON.stringify(Ontology.toStringRecord(_ontology))})`;
+    Ontology.create = (parameters = {}) => $sequenceRecord({
+        $identifier: $convertToIdentifierProperty(parameters.$identifier, parameters.$defaultNamespace),
+        $type: Right("Ontology"),
+        comment: $convertToMaybe($identityConversionFunction)(parameters.comment, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.comment.type, value)),
+        label: $convertToMaybe($identityConversionFunction)(parameters.label, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.label.type, value)),
+    }).map((object) => $monkeyPatchObject(object, { $toString: Ontology.$toString }));
+    Ontology.createUnsafe = (parameters) => Ontology.create(parameters).unsafeCoerce();
+    Ontology.fromRdfResource = $wrap_FromRdfResourceFunction(Ontology._fromRdfResource);
+    Ontology.fromRdfResourceValues = (values, options) => values.chainMap((value) => value
+        .toResource()
+        .chain((resource) => Ontology.fromRdfResource(resource, options)));
+    let Identifier;
+    (function (Identifier) {
+        Identifier.parse = $parseIdentifier;
+    })(Identifier = Ontology.Identifier || (Ontology.Identifier = {}));
+    Ontology.isOntology = (object) => object.$type === "Ontology";
+    Ontology.schema = {
+        properties: {
+            $identifier: {
+                kind: "Identifier",
+                type: { kind: "Identifier" },
+            },
+            $rdfType: {
+                fromRdfType: dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"),
+                kind: "RdfType",
+                toRdfTypes: [
+                    dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"),
+                ],
+            },
+            comment: {
+                kind: "Shacl",
+                path: $rdfs_comment,
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String", datatype: $xsd_string },
+                },
+            },
+            label: {
+                kind: "Shacl",
+                path: $rdfs_label,
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String", datatype: $xsd_string },
+                },
+            },
+        },
+    };
+    Ontology.toStringRecord = (_ontology) => $compactRecord({
+        $identifier: _ontology.$identifier().toString(),
+        label: _ontology.label.map((item) => item.toString()).extract(),
+    });
+})(Ontology || (Ontology = {}));
+export var Operation;
+(function (Operation) {
+    Operation._fromRdfResource = (resource, options) => $sequenceRecord({
+        $identifier: $identifierFromRdfResourceValues($rdfResourceIdentifierValues(resource), {
+            ...options,
+            focusResource: resource,
+            propertyPath: $rdf_subject,
+            schema: Operation.schema.properties.$identifier.type,
+        }).chain((values) => values.head()),
+        $rdfType: !options.ignoreRdfType
+            ? $ensureRdfResourceType(resource, [Operation.schema.properties.$rdfType.fromRdfType], {
+                graph: options.graph,
+            })
+            : Right(true),
+        bindings: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: Operation.schema.properties.bindings,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(OperationHttpBinding.fromRdfResourceValues),
+        }),
+        comment: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.comment,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        error: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: Operation.schema.properties.error,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(OperationError.fromRdfResourceValues),
+        }),
+        label: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.label,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        name: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: Operation.schema.properties.name,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        parameter: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: Operation.schema.properties.parameter,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($identifierFromRdfResourceValues),
+        }),
+        result: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: Operation.schema.properties.result,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($identifierFromRdfResourceValues),
+        }),
+    }).chain((properties) => Operation.create(properties));
+    Operation.$toString = (_operation) => `Operation(${JSON.stringify(Operation.toStringRecord(_operation))})`;
+    Operation.create = (parameters = {}) => $sequenceRecord({
+        $identifier: $convertToIdentifierProperty(parameters.$identifier, parameters.$defaultNamespace),
+        $type: Right("Operation"),
+        bindings: $convertToScalarSet($identityConversionFunction)(parameters.bindings, parameters.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(Operation.schema.properties.bindings.type, value)),
+        comment: $convertToMaybe($identityConversionFunction)(parameters.comment, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.comment.type, value)),
+        error: $convertToScalarSet($identityConversionFunction)(parameters.error, parameters.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(Operation.schema.properties.error.type, value)),
+        label: $convertToMaybe($identityConversionFunction)(parameters.label, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.label.type, value)),
+        name: $convertToMaybe($identityConversionFunction)(parameters.name, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(Operation.schema.properties.name.type, value)),
+        parameter: $convertToMaybe($convertToIdentifier)(parameters.parameter, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(Operation.schema.properties.parameter.type, value)),
+        result: $convertToMaybe($convertToIdentifier)(parameters.result, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(Operation.schema.properties.result.type, value)),
+    }).map((object) => $monkeyPatchObject(object, { $toString: Operation.$toString }));
+    Operation.createUnsafe = (parameters) => Operation.create(parameters).unsafeCoerce();
+    Operation.fromRdfResource = $wrap_FromRdfResourceFunction(Operation._fromRdfResource);
+    Operation.fromRdfResourceValues = (values, options) => values.chainMap((value) => value
+        .toResource()
+        .chain((resource) => Operation.fromRdfResource(resource, options)));
+    let Identifier;
+    (function (Identifier) {
+        Identifier.parse = $parseIdentifier;
+    })(Identifier = Operation.Identifier || (Operation.Identifier = {}));
+    Operation.isOperation = (object) => object.$type === "Operation";
+    Operation.schema = {
+        properties: {
+            $identifier: {
+                kind: "Identifier",
+                type: { kind: "Identifier" },
+            },
+            $rdfType: {
+                fromRdfType: dataFactory.namedNode("http://purl.org/shaclmate/ontology#Operation"),
+                kind: "RdfType",
+                toRdfTypes: [
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#Operation"),
+                ],
+            },
+            bindings: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#binding"),
+                get type() {
+                    return {
+                        kind: "Set",
+                        get itemType() {
+                            return OperationHttpBinding.schema;
+                        },
+                    };
+                },
+            },
+            comment: {
+                kind: "Shacl",
+                path: $rdfs_comment,
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String", datatype: $xsd_string },
+                },
+            },
+            error: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#error"),
+                get type() {
+                    return {
+                        kind: "Set",
+                        get itemType() {
+                            return OperationError.schema;
+                        },
+                    };
+                },
+            },
+            label: {
+                kind: "Shacl",
+                path: $rdfs_label,
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String", datatype: $xsd_string },
+                },
+            },
+            name: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#name"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String", datatype: $xsd_string },
+                },
+            },
+            parameter: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#parameter"),
+                get type() {
+                    return {
+                        kind: "Option",
+                        get itemType() {
+                            return OperationParameter.schema;
+                        },
+                    };
+                },
+            },
+            result: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#result"),
+                get type() {
+                    return {
+                        kind: "Option",
+                        get itemType() {
+                            return OperationResult.schema;
+                        },
+                    };
+                },
+            },
+        },
+    };
+    Operation.toStringRecord = (_operation) => $compactRecord({
+        $identifier: _operation.$identifier().toString(),
+        label: _operation.label.map((item) => item.toString()).extract(),
+        name: _operation.name.map((item) => item.toString()).extract(),
+    });
+})(Operation || (Operation = {}));
+export var OperationError;
+(function (OperationError) {
+    OperationError._fromRdfResource = (resource, options) => $sequenceRecord({
+        $identifier: $identifierFromRdfResourceValues($rdfResourceIdentifierValues(resource), {
+            ...options,
+            focusResource: resource,
+            propertyPath: $rdf_subject,
+            schema: OperationError.schema.properties.$identifier.type,
+        }).chain((values) => values.head()),
+        classes: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.classes,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        closed: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.closed,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($booleanFromRdfResourceValues)),
+        }),
+        comment: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.comment,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        deactivated: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.deactivated,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($booleanFromRdfResourceValues)),
+        }),
+        extern: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.extern,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($booleanFromRdfResourceValues)),
+        }),
+        fromRdfType: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.fromRdfType,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        ignoredProperties: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.ignoredProperties,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues(($iriFromRdfResourceValues))),
+        }),
+        isDefinedBy: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.isDefinedBy,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($identifierFromRdfResourceValues),
+        }),
+        label: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.label,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        message: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.message,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        nodeKind: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.nodeKind,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        properties: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: OperationError.schema.properties.properties,
+            typeFromRdfResourceValues: $setFromRdfResourceValues($identifierFromRdfResourceValues),
+        }),
+        rdfType: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.rdfType,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        severity: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.severity,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        shaclmateName: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.shaclmateName,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        subClassOf: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.subClassOf,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        toRdfTypes: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.toRdfTypes,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        tsImports: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.tsImports,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        types: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.types,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+    }).chain((properties) => OperationError.create(properties));
+    OperationError.$toString = (_operationError) => `OperationError(${JSON.stringify(OperationError.toStringRecord(_operationError))})`;
+    OperationError.create = (parameters = {}) => $sequenceRecord({
+        $identifier: $convertToIdentifierProperty(parameters.$identifier, parameters.$defaultNamespace),
+        $type: Right("OperationError"),
+        classes: $convertToScalarSet($convertToIri)(parameters.classes, parameters.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(NodeShape.schema.properties.classes.type, value)),
+        closed: $convertToMaybe($identityConversionFunction)(parameters.closed, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.closed.type, value)),
+        comment: $convertToMaybe($identityConversionFunction)(parameters.comment, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.comment.type, value)),
+        deactivated: $convertToMaybe($identityConversionFunction)(parameters.deactivated, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.deactivated.type, value)),
+        extern: $convertToMaybe($identityConversionFunction)(parameters.extern, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.extern.type, value)),
+        fromRdfType: $convertToMaybe($convertToIri)(parameters.fromRdfType, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.fromRdfType.type, value)),
+        ignoredProperties: $convertToMaybe($convertToList($convertToIri))(parameters.ignoredProperties, parameters.$defaultNamespace).chain((value) => $validateMaybe($validateArray($identityValidationFunction))(NodeShape.schema.properties.ignoredProperties.type, value)),
+        isDefinedBy: $convertToMaybe($convertToIdentifier)(parameters.isDefinedBy, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.isDefinedBy.type, value)),
+        label: $convertToMaybe($identityConversionFunction)(parameters.label, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.label.type, value)),
+        message: $convertToMaybe($identityConversionFunction)(parameters.message, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.message.type, value)),
+        nodeKind: $convertToMaybe(($convertToInIri))(parameters.nodeKind, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.nodeKind.type, value)),
+        properties: $convertToScalarSet($convertToIdentifier)(parameters.properties, parameters.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(OperationError.schema.properties.properties.type, value)),
+        rdfType: $convertToMaybe($convertToIri)(parameters.rdfType, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.rdfType.type, value)),
+        severity: $convertToMaybe(($convertToInIri))(parameters.severity, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.severity.type, value)),
+        shaclmateName: $convertToMaybe($identityConversionFunction)(parameters.shaclmateName, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.shaclmateName.type, value)),
+        subClassOf: $convertToScalarSet($convertToIri)(parameters.subClassOf, parameters.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(NodeShape.schema.properties.subClassOf.type, value)),
+        toRdfTypes: $convertToScalarSet($convertToIri)(parameters.toRdfTypes, parameters.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(NodeShape.schema.properties.toRdfTypes.type, value)),
+        tsImports: $convertToScalarSet($identityConversionFunction)(parameters.tsImports, parameters.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(NodeShape.schema.properties.tsImports.type, value)),
+        types: $convertToScalarSet($convertToIri)(parameters.types, parameters.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(NodeShape.schema.properties.types.type, value)),
+    }).map((object) => $monkeyPatchObject(object, { $toString: OperationError.$toString }));
+    OperationError.createUnsafe = (parameters) => OperationError.create(parameters).unsafeCoerce();
+    OperationError.fromRdfResource = $wrap_FromRdfResourceFunction(OperationError._fromRdfResource);
+    OperationError.fromRdfResourceValues = (values, options) => values.chainMap((value) => value
+        .toResource()
+        .chain((resource) => OperationError.fromRdfResource(resource, options)));
+    let Identifier;
+    (function (Identifier) {
+        Identifier.parse = $parseIdentifier;
+    })(Identifier = OperationError.Identifier || (OperationError.Identifier = {}));
+    OperationError.isOperationError = (object) => object.$type === "OperationError";
+    OperationError.schema = {
+        properties: {
+            $identifier: {
+                kind: "Identifier",
+                type: { kind: "Identifier" },
+            },
+            classes: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#class"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            closed: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#closed"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Boolean", datatype: $xsd_boolean },
+                },
+            },
+            comment: {
+                kind: "Shacl",
+                path: $rdfs_comment,
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String", datatype: $xsd_string },
+                },
+            },
+            deactivated: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#deactivated"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Boolean", datatype: $xsd_boolean },
+                },
+            },
+            extern: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#extern"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Boolean", datatype: $xsd_boolean },
+                },
+            },
+            fromRdfType: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#fromRdfType"),
+                type: { kind: "Option", itemType: { kind: "Iri" } },
+            },
+            ignoredProperties: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#ignoredProperties"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "Iri" },
+                    },
+                },
+            },
+            isDefinedBy: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minLength"),
+                path: $rdfs_isDefinedBy,
                 type: {
                     kind: "Option",
-                    itemType: { kind: "BigInt" },
+                    itemType: { kind: "Identifier" },
                 },
             },
-            mutable: {
+            label: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#mutable"),
+                path: $rdfs_label,
                 type: {
                     kind: "Option",
-                    itemType: { kind: "Boolean" },
+                    itemType: { kind: "String", datatype: $xsd_string },
                 },
             },
-            node: {
+            message: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#node"),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#message"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "Identifier" },
+                    itemType: { kind: "String", datatype: $xsd_string },
                 },
             },
             nodeKind: {
@@ -1022,39 +1661,13 @@ export var NodeShape;
                     },
                 },
             },
-            not: {
-                kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#not"),
-                type: {
-                    kind: "Set",
-                    itemType: { kind: "Identifier" },
-                },
-            },
-            or: {
-                kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#or"),
-                type: {
-                    kind: "Option",
-                    itemType: {
-                        kind: "List",
-                        itemType: { kind: "Identifier" },
-                    },
-                },
-            },
-            pattern: {
-                kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#pattern"),
-                type: {
-                    kind: "Option",
-                    itemType: { kind: "String" },
-                },
-            },
             properties: {
                 kind: "Shacl",
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#property"),
                 type: {
                     kind: "Set",
                     itemType: { kind: "Identifier" },
+                    minCount: 1,
                 },
             },
             rdfType: {
@@ -1079,35 +1692,12 @@ export var NodeShape;
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#name"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "String" },
+                    itemType: { kind: "String", datatype: $xsd_string },
                 },
             },
             subClassOf: {
                 kind: "Shacl",
-                path: $RdfVocabularies.rdfs.subClassOf,
-                type: { kind: "Set", itemType: { kind: "Iri" } },
-            },
-            targetClasses: {
-                kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetClass"),
-                type: { kind: "Set", itemType: { kind: "Iri" } },
-            },
-            targetNodes: {
-                kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetNode"),
-                type: {
-                    kind: "Set",
-                    itemType: { kind: "Term", types: ["NamedNode", "Literal"] },
-                },
-            },
-            targetObjectsOf: {
-                kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetObjectsOf"),
-                type: { kind: "Set", itemType: { kind: "Iri" } },
-            },
-            targetSubjectsOf: {
-                kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetSubjectsOf"),
+                path: $rdfs_subClassOf,
                 type: { kind: "Set", itemType: { kind: "Iri" } },
             },
             toRdfTypes: {
@@ -1118,132 +1708,216 @@ export var NodeShape;
             tsImports: {
                 kind: "Shacl",
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#tsImport"),
-                type: { kind: "Set", itemType: { kind: "String" } },
+                type: {
+                    kind: "Set",
+                    itemType: { kind: "String", datatype: $xsd_string },
+                },
             },
             types: {
                 kind: "Shacl",
-                path: $RdfVocabularies.rdf.type,
+                path: $rdf_type,
                 type: { kind: "Set", itemType: { kind: "Iri" } },
             },
-            xone: {
+        },
+    };
+    OperationError.toStringRecord = (_operationError) => $compactRecord({
+        $identifier: _operationError.$identifier().toString(),
+        label: _operationError.label.map((item) => item.toString()).extract(),
+        shaclmateName: _operationError.shaclmateName
+            .map((item) => item.toString())
+            .extract(),
+    });
+})(OperationError || (OperationError = {}));
+export var OperationErrorHttpBinding;
+(function (OperationErrorHttpBinding) {
+    OperationErrorHttpBinding._fromRdfResource = (resource, options) => $sequenceRecord({
+        $identifier: $identifierFromRdfResourceValues($rdfResourceIdentifierValues(resource), {
+            ...options,
+            focusResource: resource,
+            propertyPath: $rdf_subject,
+            schema: OperationErrorHttpBinding.schema.properties.$identifier.type,
+        }).chain((values) => values.head()),
+        statusCode: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: OperationErrorHttpBinding.schema.properties.statusCode,
+            typeFromRdfResourceValues: ($intFromRdfResourceValues),
+        }),
+    }).chain((properties) => OperationErrorHttpBinding.create(properties));
+    OperationErrorHttpBinding.$toString = (_operationErrorHttpBinding) => `OperationErrorHttpBinding(${JSON.stringify(OperationErrorHttpBinding.toStringRecord(_operationErrorHttpBinding))})`;
+    OperationErrorHttpBinding.create = (parameters) => $sequenceRecord({
+        $identifier: $convertToIdentifierProperty(parameters.$identifier, parameters.$defaultNamespace),
+        $type: Right("OperationErrorHttpBinding"),
+        statusCode: Either.of(parameters.statusCode),
+    }).map((object) => $monkeyPatchObject(object, {
+        $toString: OperationErrorHttpBinding.$toString,
+    }));
+    OperationErrorHttpBinding.createUnsafe = (parameters) => OperationErrorHttpBinding.create(parameters).unsafeCoerce();
+    OperationErrorHttpBinding.fromRdfResource = $wrap_FromRdfResourceFunction(OperationErrorHttpBinding._fromRdfResource);
+    OperationErrorHttpBinding.fromRdfResourceValues = (values, options) => values.chainMap((value) => value
+        .toResource()
+        .chain((resource) => OperationErrorHttpBinding.fromRdfResource(resource, options)));
+    let Identifier;
+    (function (Identifier) {
+        Identifier.parse = $parseIdentifier;
+    })(Identifier = OperationErrorHttpBinding.Identifier || (OperationErrorHttpBinding.Identifier = {}));
+    OperationErrorHttpBinding.isOperationErrorHttpBinding = (object) => object.$type === "OperationErrorHttpBinding";
+    OperationErrorHttpBinding.schema = {
+        properties: {
+            $identifier: {
+                kind: "Identifier",
+                type: { kind: "Identifier" },
+            },
+            statusCode: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#xone"),
-                type: {
-                    kind: "Option",
-                    itemType: {
-                        kind: "List",
-                        itemType: { kind: "Identifier" },
-                    },
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#httpStatusCode"),
+                get type() {
+                    return OperationErrorHttpBindingStatusCode.schema;
                 },
             },
         },
     };
-    NodeShape.toStringRecord = (_nodeShape) => $compactRecord({
-        $identifier: _nodeShape.$identifier().toString(),
-        label: _nodeShape.label.map((item) => item.toString()).extract(),
-        shaclmateName: _nodeShape.shaclmateName
-            .map((item) => item.toString())
-            .extract(),
+    OperationErrorHttpBinding.toStringRecord = (_operationErrorHttpBinding) => $compactRecord({
+        $identifier: _operationErrorHttpBinding.$identifier().toString(),
     });
-})(NodeShape || (NodeShape = {}));
-export var Ontology;
-(function (Ontology) {
-    Ontology._fromRdfResource = (resource, options) => (!options.ignoreRdfType
-        ? $ensureRdfResourceType(resource, [Ontology.schema.properties.$rdfType.fromRdfType], { graph: options.graph })
-        : Right(true)).chain((_rdfTypeCheck) => $sequenceRecord({
+})(OperationErrorHttpBinding || (OperationErrorHttpBinding = {}));
+export var OperationErrorHttpBindingStatusCode;
+(function (OperationErrorHttpBindingStatusCode) {
+    OperationErrorHttpBindingStatusCode.schema = {
+        kind: "Int",
+        in: [
+            400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414,
+            415, 416, 417, 418, 421, 422, 423, 424, 425, 426, 428, 429, 431, 451, 500,
+            501, 502, 503, 504, 505, 506, 507, 508, 510, 511,
+        ],
+        datatype: $xsd_int,
+    };
+})(OperationErrorHttpBindingStatusCode || (OperationErrorHttpBindingStatusCode = {}));
+export var OperationHttpBinding;
+(function (OperationHttpBinding) {
+    OperationHttpBinding._fromRdfResource = (resource, options) => $sequenceRecord({
         $identifier: $identifierFromRdfResourceValues($rdfResourceIdentifierValues(resource), {
             ...options,
             focusResource: resource,
-            propertyPath: $RdfVocabularies.rdf.subject,
-            schema: Ontology.schema.properties.$identifier.type,
+            propertyPath: $rdf_subject,
+            schema: OperationHttpBinding.schema.properties.$identifier.type,
         }).chain((values) => values.head()),
-        comment: $shaclPropertyFromRdf({
+        method: $shaclPropertyFromRdf({
             ...options,
             focusResource: resource,
             ignoreRdfType: true,
-            propertySchema: NodeShape.schema.properties.comment,
+            propertySchema: OperationHttpBinding.schema.properties.method,
             typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
         }),
-        label: $shaclPropertyFromRdf({
+        urlTemplate: $shaclPropertyFromRdf({
             ...options,
             focusResource: resource,
             ignoreRdfType: true,
-            propertySchema: NodeShape.schema.properties.label,
-            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+            propertySchema: OperationHttpBinding.schema.properties.urlTemplate,
+            typeFromRdfResourceValues: ($stringFromRdfResourceValues),
         }),
-    }).chain((properties) => Ontology.create(properties)));
-    Ontology.$toString = (_ontology) => `Ontology(${JSON.stringify(Ontology.toStringRecord(_ontology))})`;
-    Ontology.create = (parameters) => $sequenceRecord({
-        $identifier: $convertToIdentifierProperty(parameters?.$identifier, parameters?.$defaultNamespace),
-        comment: $convertToMaybe($identityConversionFunction)(parameters?.comment, parameters?.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.comment.type, value)),
-        label: $convertToMaybe($identityConversionFunction)(parameters?.label, parameters?.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.label.type, value)),
-    })
-        .map((properties) => ({ ...properties, $type: "Ontology" }))
-        .map((object) => $monkeyPatchObject(object, { $toString: Ontology.$toString }));
-    function createUnsafe(parameters) {
-        return Ontology.create(parameters).unsafeCoerce();
-    }
-    Ontology.createUnsafe = createUnsafe;
-    Ontology.fromRdfResource = $wrap_FromRdfResourceFunction(Ontology._fromRdfResource);
-    Ontology.fromRdfResourceValues = (values, options) => values.chainMap((value) => value
+    }).chain((properties) => OperationHttpBinding.create(properties));
+    OperationHttpBinding.$toString = (_operationHttpBinding) => `OperationHttpBinding(${JSON.stringify(OperationHttpBinding.toStringRecord(_operationHttpBinding))})`;
+    OperationHttpBinding.create = (parameters) => $sequenceRecord({
+        $identifier: $convertToIdentifierProperty(parameters.$identifier, parameters.$defaultNamespace),
+        $type: Right("OperationHttpBinding"),
+        method: $convertToMaybe($identityConversionFunction)(parameters.method, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(OperationHttpBinding.schema.properties.method.type, value)),
+        urlTemplate: Either.of(parameters.urlTemplate),
+    }).map((object) => $monkeyPatchObject(object, { $toString: OperationHttpBinding.$toString }));
+    OperationHttpBinding.createUnsafe = (parameters) => OperationHttpBinding.create(parameters).unsafeCoerce();
+    OperationHttpBinding.fromRdfResource = $wrap_FromRdfResourceFunction(OperationHttpBinding._fromRdfResource);
+    OperationHttpBinding.fromRdfResourceValues = (values, options) => values.chainMap((value) => value
         .toResource()
-        .chain((resource) => Ontology.fromRdfResource(resource, options)));
+        .chain((resource) => OperationHttpBinding.fromRdfResource(resource, options)));
     let Identifier;
     (function (Identifier) {
         Identifier.parse = $parseIdentifier;
-        Identifier.stringify = NTriplesTerm.stringify;
-    })(Identifier = Ontology.Identifier || (Ontology.Identifier = {}));
-    Ontology.isOntology = (object) => object.$type === "Ontology";
-    Ontology.schema = {
+    })(Identifier = OperationHttpBinding.Identifier || (OperationHttpBinding.Identifier = {}));
+    OperationHttpBinding.isOperationHttpBinding = (object) => object.$type === "OperationHttpBinding";
+    OperationHttpBinding.schema = {
         properties: {
             $identifier: {
                 kind: "Identifier",
                 type: { kind: "Identifier" },
             },
-            $rdfType: {
-                fromRdfType: dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"),
-                kind: "RdfType",
-                toRdfTypes: [
-                    dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"),
-                ],
-            },
-            $type: { kind: "Discriminant", value: "Ontology" },
-            comment: {
+            method: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
-                type: {
-                    kind: "Option",
-                    itemType: { kind: "String" },
+                path: dataFactory.namedNode("http://schema.org/httpMethod"),
+                get type() {
+                    return {
+                        kind: "Option",
+                        get itemType() {
+                            return OperationHttpBindingMethod.schema;
+                        },
+                    };
                 },
             },
-            label: {
+            urlTemplate: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
-                type: {
-                    kind: "Option",
-                    itemType: { kind: "String" },
-                },
+                path: dataFactory.namedNode("http://schema.org/urlTemplate"),
+                type: { kind: "String", datatype: $xsd_string },
             },
         },
     };
-    Ontology.toStringRecord = (_ontology) => $compactRecord({
-        $identifier: _ontology.$identifier().toString(),
-        label: _ontology.label.map((item) => item.toString()).extract(),
+    OperationHttpBinding.toStringRecord = (_operationHttpBinding) => $compactRecord({
+        $identifier: _operationHttpBinding.$identifier().toString(),
     });
-})(Ontology || (Ontology = {}));
+})(OperationHttpBinding || (OperationHttpBinding = {}));
+export var OperationHttpBindingMethod;
+(function (OperationHttpBindingMethod) {
+    OperationHttpBindingMethod.schema = {
+        kind: "String",
+        in: ["DELETE", "GET", "POST", "PUT"],
+        datatype: $xsd_string,
+    };
+})(OperationHttpBindingMethod || (OperationHttpBindingMethod = {}));
+export var OperationHttpBindingStatusCode;
+(function (OperationHttpBindingStatusCode) {
+    OperationHttpBindingStatusCode.schema = {
+        kind: "Int",
+        in: [200, 201, 202, 203, 204, 205, 206, 207, 208, 226],
+        datatype: $xsd_int,
+    };
+})(OperationHttpBindingStatusCode || (OperationHttpBindingStatusCode = {}));
+export var OperationParameter;
+(function (OperationParameter) {
+    OperationParameter.schema = { kind: "Identifier" };
+})(OperationParameter || (OperationParameter = {}));
+export var OperationParameterHttpBindingContentType;
+(function (OperationParameterHttpBindingContentType) {
+    OperationParameterHttpBindingContentType.schema = {
+        kind: "String",
+        in: ["application/json"],
+        datatype: $xsd_string,
+    };
+})(OperationParameterHttpBindingContentType || (OperationParameterHttpBindingContentType = {}));
+export var OperationResult;
+(function (OperationResult) {
+    OperationResult.schema = { kind: "Identifier" };
+})(OperationResult || (OperationResult = {}));
+export var OperationResultHttpBindingContentType;
+(function (OperationResultHttpBindingContentType) {
+    OperationResultHttpBindingContentType.schema = {
+        kind: "String",
+        in: ["application/json"],
+        datatype: $xsd_string,
+    };
+})(OperationResultHttpBindingContentType || (OperationResultHttpBindingContentType = {}));
 export var PropertyGroup;
 (function (PropertyGroup) {
-    PropertyGroup._fromRdfResource = (resource, options) => (!options.ignoreRdfType
-        ? $ensureRdfResourceType(resource, [PropertyGroup.schema.properties.$rdfType.fromRdfType], {
-            graph: options.graph,
-        })
-        : Right(true)).chain((_rdfTypeCheck) => $sequenceRecord({
+    PropertyGroup._fromRdfResource = (resource, options) => $sequenceRecord({
         $identifier: $identifierFromRdfResourceValues($rdfResourceIdentifierValues(resource), {
             ...options,
             focusResource: resource,
-            propertyPath: $RdfVocabularies.rdf.subject,
+            propertyPath: $rdf_subject,
             schema: PropertyGroup.schema.properties.$identifier.type,
         }).chain((values) => values.head()),
+        $rdfType: !options.ignoreRdfType
+            ? $ensureRdfResourceType(resource, [PropertyGroup.schema.properties.$rdfType.fromRdfType], {
+                graph: options.graph,
+            })
+            : Right(true),
         comment: $shaclPropertyFromRdf({
             ...options,
             focusResource: resource,
@@ -1258,19 +1932,15 @@ export var PropertyGroup;
             propertySchema: NodeShape.schema.properties.label,
             typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
         }),
-    }).chain((properties) => PropertyGroup.create(properties)));
+    }).chain((properties) => PropertyGroup.create(properties));
     PropertyGroup.$toString = (_propertyGroup) => `PropertyGroup(${JSON.stringify(PropertyGroup.toStringRecord(_propertyGroup))})`;
-    PropertyGroup.create = (parameters) => $sequenceRecord({
-        $identifier: $convertToIdentifierProperty(parameters?.$identifier, parameters?.$defaultNamespace),
-        comment: $convertToMaybe($identityConversionFunction)(parameters?.comment, parameters?.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.comment.type, value)),
-        label: $convertToMaybe($identityConversionFunction)(parameters?.label, parameters?.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.label.type, value)),
-    })
-        .map((properties) => ({ ...properties, $type: "PropertyGroup" }))
-        .map((object) => $monkeyPatchObject(object, { $toString: PropertyGroup.$toString }));
-    function createUnsafe(parameters) {
-        return PropertyGroup.create(parameters).unsafeCoerce();
-    }
-    PropertyGroup.createUnsafe = createUnsafe;
+    PropertyGroup.create = (parameters = {}) => $sequenceRecord({
+        $identifier: $convertToIdentifierProperty(parameters.$identifier, parameters.$defaultNamespace),
+        $type: Right("PropertyGroup"),
+        comment: $convertToMaybe($identityConversionFunction)(parameters.comment, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.comment.type, value)),
+        label: $convertToMaybe($identityConversionFunction)(parameters.label, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.label.type, value)),
+    }).map((object) => $monkeyPatchObject(object, { $toString: PropertyGroup.$toString }));
+    PropertyGroup.createUnsafe = (parameters) => PropertyGroup.create(parameters).unsafeCoerce();
     PropertyGroup.fromRdfResource = $wrap_FromRdfResourceFunction(PropertyGroup._fromRdfResource);
     PropertyGroup.fromRdfResourceValues = (values, options) => values.chainMap((value) => value
         .toResource()
@@ -1278,7 +1948,6 @@ export var PropertyGroup;
     let Identifier;
     (function (Identifier) {
         Identifier.parse = $parseIdentifier;
-        Identifier.stringify = NTriplesTerm.stringify;
     })(Identifier = PropertyGroup.Identifier || (PropertyGroup.Identifier = {}));
     PropertyGroup.isPropertyGroup = (object) => object.$type === "PropertyGroup";
     PropertyGroup.schema = {
@@ -1294,21 +1963,20 @@ export var PropertyGroup;
                     dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup"),
                 ],
             },
-            $type: { kind: "Discriminant", value: "PropertyGroup" },
             comment: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
+                path: $rdfs_comment,
                 type: {
                     kind: "Option",
-                    itemType: { kind: "String" },
+                    itemType: { kind: "String", datatype: $xsd_string },
                 },
             },
             label: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
+                path: $rdfs_label,
                 type: {
                     kind: "Option",
-                    itemType: { kind: "String" },
+                    itemType: { kind: "String", datatype: $xsd_string },
                 },
             },
         },
@@ -1320,17 +1988,18 @@ export var PropertyGroup;
 })(PropertyGroup || (PropertyGroup = {}));
 export var PropertyShape;
 (function (PropertyShape) {
-    PropertyShape._fromRdfResource = (resource, options) => (!options.ignoreRdfType
-        ? $ensureRdfResourceType(resource, [PropertyShape.schema.properties.$rdfType.fromRdfType], {
-            graph: options.graph,
-        })
-        : Right(true)).chain((_rdfTypeCheck) => $sequenceRecord({
+    PropertyShape._fromRdfResource = (resource, options) => $sequenceRecord({
         $identifier: $identifierFromRdfResourceValues($rdfResourceIdentifierValues(resource), {
             ...options,
             focusResource: resource,
-            propertyPath: $RdfVocabularies.rdf.subject,
+            propertyPath: $rdf_subject,
             schema: PropertyShape.schema.properties.$identifier.type,
         }).chain((values) => values.head()),
+        $rdfType: !options.ignoreRdfType
+            ? $ensureRdfResourceType(resource, [PropertyShape.schema.properties.$rdfType.fromRdfType], {
+                graph: options.graph,
+            })
+            : Right(true),
         and: $shaclPropertyFromRdf({
             ...options,
             focusResource: resource,
@@ -1688,10 +2357,11 @@ export var PropertyShape;
             propertySchema: NodeShape.schema.properties.xone,
             typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues($identifierFromRdfResourceValues)),
         }),
-    }).chain((properties) => PropertyShape.create(properties)));
+    }).chain((properties) => PropertyShape.create(properties));
     PropertyShape.$toString = (_propertyShape) => `PropertyShape(${JSON.stringify(PropertyShape.toStringRecord(_propertyShape))})`;
     PropertyShape.create = (parameters) => $sequenceRecord({
         $identifier: $convertToIdentifierProperty(parameters.$identifier, parameters.$defaultNamespace),
+        $type: Right("PropertyShape"),
         and: $convertToMaybe($convertToList($convertToIdentifier))(parameters.and, parameters.$defaultNamespace).chain((value) => $validateMaybe($validateArray($identityValidationFunction))(NodeShape.schema.properties.and.type, value)),
         classes: $convertToScalarSet($convertToIri)(parameters.classes, parameters.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(NodeShape.schema.properties.classes.type, value)),
         comment: $convertToMaybe($identityConversionFunction)(parameters.comment, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.comment.type, value)),
@@ -1712,15 +2382,15 @@ export var PropertyShape;
         languageIn: $convertToMaybe($convertToList($identityConversionFunction))(parameters.languageIn, parameters.$defaultNamespace).chain((value) => $validateMaybe($validateArray($identityValidationFunction))(NodeShape.schema.properties.languageIn.type, value)),
         lessThan: $convertToScalarSet($convertToIri)(parameters.lessThan, parameters.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(PropertyShape.schema.properties.lessThan.type, value)),
         lessThanOrEquals: $convertToScalarSet($convertToIri)(parameters.lessThanOrEquals, parameters.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(PropertyShape.schema.properties.lessThanOrEquals.type, value)),
-        maxCount: $convertToMaybe($identityConversionFunction)(parameters.maxCount, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.maxCount.type, value)),
+        maxCount: $convertToMaybe($convertToBigInt)(parameters.maxCount, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.maxCount.type, value)),
         maxExclusive: $convertToMaybe($convertToLiteral)(parameters.maxExclusive, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.maxExclusive.type, value)),
         maxInclusive: $convertToMaybe($convertToLiteral)(parameters.maxInclusive, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.maxInclusive.type, value)),
-        maxLength: $convertToMaybe($identityConversionFunction)(parameters.maxLength, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.maxLength.type, value)),
+        maxLength: $convertToMaybe($convertToBigInt)(parameters.maxLength, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.maxLength.type, value)),
         message: $convertToMaybe($identityConversionFunction)(parameters.message, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.message.type, value)),
-        minCount: $convertToMaybe($identityConversionFunction)(parameters.minCount, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.minCount.type, value)),
+        minCount: $convertToMaybe($convertToBigInt)(parameters.minCount, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.minCount.type, value)),
         minExclusive: $convertToMaybe($convertToLiteral)(parameters.minExclusive, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.minExclusive.type, value)),
         minInclusive: $convertToMaybe($convertToLiteral)(parameters.minInclusive, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.minInclusive.type, value)),
-        minLength: $convertToMaybe($identityConversionFunction)(parameters.minLength, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.minLength.type, value)),
+        minLength: $convertToMaybe($convertToBigInt)(parameters.minLength, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.minLength.type, value)),
         mutable: $convertToMaybe($identityConversionFunction)(parameters.mutable, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.mutable.type, value)),
         name: $convertToMaybe($identityConversionFunction)(parameters.name, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.name.type, value)),
         node: $convertToMaybe($convertToIdentifier)(parameters.node, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.node.type, value)),
@@ -1730,8 +2400,8 @@ export var PropertyShape;
         order: $convertToMaybe($identityConversionFunction)(parameters.order, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.order.type, value)),
         path: Either.of(parameters.path),
         pattern: $convertToMaybe($identityConversionFunction)(parameters.pattern, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.pattern.type, value)),
-        qualifiedMaxCount: $convertToMaybe($identityConversionFunction)(parameters.qualifiedMaxCount, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.qualifiedMaxCount.type, value)),
-        qualifiedMinCount: $convertToMaybe($identityConversionFunction)(parameters.qualifiedMinCount, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.qualifiedMinCount.type, value)),
+        qualifiedMaxCount: $convertToMaybe($convertToBigInt)(parameters.qualifiedMaxCount, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.qualifiedMaxCount.type, value)),
+        qualifiedMinCount: $convertToMaybe($convertToBigInt)(parameters.qualifiedMinCount, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.qualifiedMinCount.type, value)),
         qualifiedValueShape: $convertToMaybe($convertToIdentifier)(parameters.qualifiedValueShape, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.qualifiedValueShape.type, value)),
         qualifiedValueShapesDisjoint: $convertToMaybe($identityConversionFunction)(parameters.qualifiedValueShapesDisjoint, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.qualifiedValueShapesDisjoint.type, value)),
         resolve: $convertToMaybe($convertToIdentifier)(parameters.resolve, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.resolve.type, value)),
@@ -1743,13 +2413,8 @@ export var PropertyShape;
         targetSubjectsOf: $convertToScalarSet($convertToIri)(parameters.targetSubjectsOf, parameters.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(NodeShape.schema.properties.targetSubjectsOf.type, value)),
         uniqueLang: $convertToMaybe($identityConversionFunction)(parameters.uniqueLang, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.uniqueLang.type, value)),
         xone: $convertToMaybe($convertToList($convertToIdentifier))(parameters.xone, parameters.$defaultNamespace).chain((value) => $validateMaybe($validateArray($identityValidationFunction))(NodeShape.schema.properties.xone.type, value)),
-    })
-        .map((properties) => ({ ...properties, $type: "PropertyShape" }))
-        .map((object) => $monkeyPatchObject(object, { $toString: PropertyShape.$toString }));
-    function createUnsafe(parameters) {
-        return PropertyShape.create(parameters).unsafeCoerce();
-    }
-    PropertyShape.createUnsafe = createUnsafe;
+    }).map((object) => $monkeyPatchObject(object, { $toString: PropertyShape.$toString }));
+    PropertyShape.createUnsafe = (parameters) => PropertyShape.create(parameters).unsafeCoerce();
     PropertyShape.fromRdfResource = $wrap_FromRdfResourceFunction(PropertyShape._fromRdfResource);
     PropertyShape.fromRdfResourceValues = (values, options) => values.chainMap((value) => value
         .toResource()
@@ -1757,7 +2422,6 @@ export var PropertyShape;
     let Identifier;
     (function (Identifier) {
         Identifier.parse = $parseIdentifier;
-        Identifier.stringify = NTriplesTerm.stringify;
     })(Identifier = PropertyShape.Identifier || (PropertyShape.Identifier = {}));
     PropertyShape.isPropertyShape = (object) => object.$type === "PropertyShape";
     PropertyShape.schema = {
@@ -1773,7 +2437,6 @@ export var PropertyShape;
                     dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"),
                 ],
             },
-            $type: { kind: "Discriminant", value: "PropertyShape" },
             and: {
                 kind: "Shacl",
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#and"),
@@ -1792,10 +2455,10 @@ export var PropertyShape;
             },
             comment: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
+                path: $rdfs_comment,
                 type: {
                     kind: "Option",
-                    itemType: { kind: "String" },
+                    itemType: { kind: "String", datatype: $xsd_string },
                 },
             },
             datatype: {
@@ -1808,7 +2471,7 @@ export var PropertyShape;
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#deactivated"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "Boolean" },
+                    itemType: { kind: "Boolean", datatype: $xsd_boolean },
                 },
             },
             defaultValue: {
@@ -1824,7 +2487,7 @@ export var PropertyShape;
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#description"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "String" },
+                    itemType: { kind: "String", datatype: $xsd_string },
                 },
             },
             disjoint: {
@@ -1837,8 +2500,8 @@ export var PropertyShape;
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#display"),
                 type: {
                     kind: "DefaultValue",
-                    itemType: { kind: "Boolean" },
-                    defaultValue: dataFactory.literal("false", $RdfVocabularies.xsd.boolean),
+                    itemType: { kind: "Boolean", datatype: $xsd_boolean },
+                    defaultValue: dataFactory.literal("false", $xsd_boolean),
                 },
             },
             equals: {
@@ -1851,7 +2514,7 @@ export var PropertyShape;
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#flags"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "String" },
+                    itemType: { kind: "String", datatype: $xsd_string },
                 },
             },
             groups: {
@@ -1875,8 +2538,8 @@ export var PropertyShape;
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#ignore"),
                 type: {
                     kind: "DefaultValue",
-                    itemType: { kind: "Boolean" },
-                    defaultValue: dataFactory.literal("false", $RdfVocabularies.xsd.boolean),
+                    itemType: { kind: "Boolean", datatype: $xsd_boolean },
+                    defaultValue: dataFactory.literal("false", $xsd_boolean),
                 },
             },
             in_: {
@@ -1895,7 +2558,7 @@ export var PropertyShape;
             },
             isDefinedBy: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#isDefinedBy"),
+                path: $rdfs_isDefinedBy,
                 type: {
                     kind: "Option",
                     itemType: { kind: "Identifier" },
@@ -1903,10 +2566,10 @@ export var PropertyShape;
             },
             label: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
+                path: $rdfs_label,
                 type: {
                     kind: "Option",
-                    itemType: { kind: "String" },
+                    itemType: { kind: "String", datatype: $xsd_string },
                 },
             },
             languageIn: {
@@ -1916,7 +2579,7 @@ export var PropertyShape;
                     kind: "Option",
                     itemType: {
                         kind: "List",
-                        itemType: { kind: "String" },
+                        itemType: { kind: "String", datatype: $xsd_string },
                     },
                 },
             },
@@ -1935,7 +2598,7 @@ export var PropertyShape;
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxCount"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "BigInt" },
+                    itemType: { kind: "BigInt", datatype: $xsd_integer },
                 },
             },
             maxExclusive: {
@@ -1959,7 +2622,7 @@ export var PropertyShape;
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxLength"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "BigInt" },
+                    itemType: { kind: "BigInt", datatype: $xsd_integer },
                 },
             },
             message: {
@@ -1967,7 +2630,7 @@ export var PropertyShape;
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#message"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "String" },
+                    itemType: { kind: "String", datatype: $xsd_string },
                 },
             },
             minCount: {
@@ -1975,7 +2638,7 @@ export var PropertyShape;
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minCount"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "BigInt" },
+                    itemType: { kind: "BigInt", datatype: $xsd_integer },
                 },
             },
             minExclusive: {
@@ -1999,7 +2662,7 @@ export var PropertyShape;
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minLength"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "BigInt" },
+                    itemType: { kind: "BigInt", datatype: $xsd_integer },
                 },
             },
             mutable: {
@@ -2007,7 +2670,7 @@ export var PropertyShape;
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#mutable"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "Boolean" },
+                    itemType: { kind: "Boolean", datatype: $xsd_boolean },
                 },
             },
             name: {
@@ -2015,7 +2678,7 @@ export var PropertyShape;
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#name"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "String" },
+                    itemType: { kind: "String", datatype: $xsd_string },
                 },
             },
             node: {
@@ -2066,7 +2729,10 @@ export var PropertyShape;
             order: {
                 kind: "Shacl",
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#order"),
-                type: { kind: "Option", itemType: { kind: "Float" } },
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Float", datatype: $xsd_double },
+                },
             },
             path: {
                 kind: "Shacl",
@@ -2080,7 +2746,7 @@ export var PropertyShape;
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#pattern"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "String" },
+                    itemType: { kind: "String", datatype: $xsd_string },
                 },
             },
             qualifiedMaxCount: {
@@ -2088,7 +2754,7 @@ export var PropertyShape;
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#qualifiedMaxCount"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "BigInt" },
+                    itemType: { kind: "BigInt", datatype: $xsd_integer },
                 },
             },
             qualifiedMinCount: {
@@ -2096,7 +2762,7 @@ export var PropertyShape;
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#qualifiedMinCount"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "BigInt" },
+                    itemType: { kind: "BigInt", datatype: $xsd_integer },
                 },
             },
             qualifiedValueShape: {
@@ -2112,7 +2778,7 @@ export var PropertyShape;
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#qualifiedValueShapesDisjoint"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "Boolean" },
+                    itemType: { kind: "Boolean", datatype: $xsd_boolean },
                 },
             },
             resolve: {
@@ -2140,7 +2806,7 @@ export var PropertyShape;
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#name"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "String" },
+                    itemType: { kind: "String", datatype: $xsd_string },
                 },
             },
             targetClasses: {
@@ -2171,7 +2837,7 @@ export var PropertyShape;
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#uniqueLang"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "Boolean" },
+                    itemType: { kind: "Boolean", datatype: $xsd_boolean },
                 },
             },
             xone: {
@@ -2197,6 +2863,123 @@ export var PropertyShape;
             .extract(),
     });
 })(PropertyShape || (PropertyShape = {}));
+export var Service;
+(function (Service) {
+    Service._fromRdfResource = (resource, options) => $sequenceRecord({
+        $identifier: $identifierFromRdfResourceValues($rdfResourceIdentifierValues(resource), {
+            ...options,
+            focusResource: resource,
+            propertyPath: $rdf_subject,
+            schema: Service.schema.properties.$identifier.type,
+        }).chain((values) => values.head()),
+        $rdfType: !options.ignoreRdfType
+            ? $ensureRdfResourceType(resource, [Service.schema.properties.$rdfType.fromRdfType], { graph: options.graph })
+            : Right(true),
+        comment: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.comment,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        label: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: NodeShape.schema.properties.label,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        name: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: Service.schema.properties.name,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        operations: $shaclPropertyFromRdf({
+            ...options,
+            focusResource: resource,
+            ignoreRdfType: true,
+            propertySchema: Service.schema.properties.operations,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(Operation.fromRdfResourceValues),
+        }),
+    }).chain((properties) => Service.create(properties));
+    Service.$toString = (_service) => `Service(${JSON.stringify(Service.toStringRecord(_service))})`;
+    Service.create = (parameters = {}) => $sequenceRecord({
+        $identifier: $convertToIdentifierProperty(parameters.$identifier, parameters.$defaultNamespace),
+        $type: Right("Service"),
+        comment: $convertToMaybe($identityConversionFunction)(parameters.comment, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.comment.type, value)),
+        label: $convertToMaybe($identityConversionFunction)(parameters.label, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.label.type, value)),
+        name: $convertToMaybe($identityConversionFunction)(parameters.name, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(Service.schema.properties.name.type, value)),
+        operations: $convertToScalarSet($identityConversionFunction)(parameters.operations, parameters.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(Service.schema.properties.operations.type, value)),
+    }).map((object) => $monkeyPatchObject(object, { $toString: Service.$toString }));
+    Service.createUnsafe = (parameters) => Service.create(parameters).unsafeCoerce();
+    Service.fromRdfResource = $wrap_FromRdfResourceFunction(Service._fromRdfResource);
+    Service.fromRdfResourceValues = (values, options) => values.chainMap((value) => value
+        .toResource()
+        .chain((resource) => Service.fromRdfResource(resource, options)));
+    let Identifier;
+    (function (Identifier) {
+        Identifier.parse = $parseIdentifier;
+    })(Identifier = Service.Identifier || (Service.Identifier = {}));
+    Service.isService = (object) => object.$type === "Service";
+    Service.schema = {
+        properties: {
+            $identifier: {
+                kind: "Identifier",
+                type: { kind: "Identifier" },
+            },
+            $rdfType: {
+                fromRdfType: dataFactory.namedNode("http://purl.org/shaclmate/ontology#Service"),
+                kind: "RdfType",
+                toRdfTypes: [
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#Service"),
+                ],
+            },
+            comment: {
+                kind: "Shacl",
+                path: $rdfs_comment,
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String", datatype: $xsd_string },
+                },
+            },
+            label: {
+                kind: "Shacl",
+                path: $rdfs_label,
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String", datatype: $xsd_string },
+                },
+            },
+            name: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#name"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String", datatype: $xsd_string },
+                },
+            },
+            operations: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#operation"),
+                get type() {
+                    return {
+                        kind: "Set",
+                        get itemType() {
+                            return Operation.schema;
+                        },
+                    };
+                },
+            },
+        },
+    };
+    Service.toStringRecord = (_service) => $compactRecord({
+        $identifier: _service.$identifier().toString(),
+        label: _service.label.map((item) => item.toString()).extract(),
+        name: _service.name.map((item) => item.toString()).extract(),
+    });
+})(Service || (Service = {}));
 export var Severity;
 (function (Severity) {
     const inValues = [
@@ -2212,17 +2995,18 @@ export var Severity;
 })(Severity || (Severity = {}));
 export var ValidationReport;
 (function (ValidationReport) {
-    ValidationReport._fromRdfResource = (resource, options) => (!options.ignoreRdfType
-        ? $ensureRdfResourceType(resource, [ValidationReport.schema.properties.$rdfType.fromRdfType], {
-            graph: options.graph,
-        })
-        : Right(true)).chain((_rdfTypeCheck) => $sequenceRecord({
+    ValidationReport._fromRdfResource = (resource, options) => $sequenceRecord({
         $identifier: $identifierFromRdfResourceValues($rdfResourceIdentifierValues(resource), {
             ...options,
             focusResource: resource,
-            propertyPath: $RdfVocabularies.rdf.subject,
+            propertyPath: $rdf_subject,
             schema: ValidationReport.schema.properties.$identifier.type,
         }).chain((values) => values.head()),
+        $rdfType: !options.ignoreRdfType
+            ? $ensureRdfResourceType(resource, [ValidationReport.schema.properties.$rdfType.fromRdfType], {
+                graph: options.graph,
+            })
+            : Right(true),
         conforms: $shaclPropertyFromRdf({
             ...options,
             focusResource: resource,
@@ -2244,23 +3028,16 @@ export var ValidationReport;
             propertySchema: ValidationReport.schema.properties.shapesGraphWellFormed,
             typeFromRdfResourceValues: $maybeFromRdfResourceValues(($booleanFromRdfResourceValues)),
         }),
-    }).chain((properties) => ValidationReport.create(properties)));
+    }).chain((properties) => ValidationReport.create(properties));
     ValidationReport.$toString = (_validationReport) => `ValidationReport(${JSON.stringify(ValidationReport.toStringRecord(_validationReport))})`;
     ValidationReport.create = (parameters) => $sequenceRecord({
         $identifier: $convertToIdentifierProperty(parameters.$identifier, parameters.$defaultNamespace),
+        $type: Right("ValidationReport"),
         conforms: Either.of(parameters.conforms),
         results: $convertToScalarSet($identityConversionFunction)(parameters.results, parameters.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(ValidationReport.schema.properties.results.type, value)),
         shapesGraphWellFormed: $convertToMaybe($identityConversionFunction)(parameters.shapesGraphWellFormed, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(ValidationReport.schema.properties.shapesGraphWellFormed.type, value)),
-    })
-        .map((properties) => ({
-        ...properties,
-        $type: "ValidationReport",
-    }))
-        .map((object) => $monkeyPatchObject(object, { $toString: ValidationReport.$toString }));
-    function createUnsafe(parameters) {
-        return ValidationReport.create(parameters).unsafeCoerce();
-    }
-    ValidationReport.createUnsafe = createUnsafe;
+    }).map((object) => $monkeyPatchObject(object, { $toString: ValidationReport.$toString }));
+    ValidationReport.createUnsafe = (parameters) => ValidationReport.create(parameters).unsafeCoerce();
     ValidationReport.fromRdfResource = $wrap_FromRdfResourceFunction(ValidationReport._fromRdfResource);
     ValidationReport.fromRdfResourceValues = (values, options) => values.chainMap((value) => value
         .toResource()
@@ -2268,7 +3045,6 @@ export var ValidationReport;
     let Identifier;
     (function (Identifier) {
         Identifier.parse = $parseIdentifier;
-        Identifier.stringify = NTriplesTerm.stringify;
     })(Identifier = ValidationReport.Identifier || (ValidationReport.Identifier = {}));
     ValidationReport.isValidationReport = (object) => object.$type === "ValidationReport";
     ValidationReport.schema = {
@@ -2284,11 +3060,10 @@ export var ValidationReport;
                     dataFactory.namedNode("http://www.w3.org/ns/shacl#ValidationReport"),
                 ],
             },
-            $type: { kind: "Discriminant", value: "ValidationReport" },
             conforms: {
                 kind: "Shacl",
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#conforms"),
-                type: { kind: "Boolean" },
+                type: { kind: "Boolean", datatype: $xsd_boolean },
             },
             results: {
                 kind: "Shacl",
@@ -2307,7 +3082,7 @@ export var ValidationReport;
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#shapesGraphWellFormed"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "Boolean" },
+                    itemType: { kind: "Boolean", datatype: $xsd_boolean },
                 },
             },
         },
@@ -2316,17 +3091,18 @@ export var ValidationReport;
 })(ValidationReport || (ValidationReport = {}));
 export var ValidationResult;
 (function (ValidationResult) {
-    ValidationResult._fromRdfResource = (resource, options) => (!options.ignoreRdfType
-        ? $ensureRdfResourceType(resource, [ValidationResult.schema.properties.$rdfType.fromRdfType], {
-            graph: options.graph,
-        })
-        : Right(true)).chain((_rdfTypeCheck) => $sequenceRecord({
+    ValidationResult._fromRdfResource = (resource, options) => $sequenceRecord({
         $identifier: $identifierFromRdfResourceValues($rdfResourceIdentifierValues(resource), {
             ...options,
             focusResource: resource,
-            propertyPath: $RdfVocabularies.rdf.subject,
+            propertyPath: $rdf_subject,
             schema: ValidationResult.schema.properties.$identifier.type,
         }).chain((values) => values.head()),
+        $rdfType: !options.ignoreRdfType
+            ? $ensureRdfResourceType(resource, [ValidationResult.schema.properties.$rdfType.fromRdfType], {
+                graph: options.graph,
+            })
+            : Right(true),
         details: $shaclPropertyFromRdf({
             ...options,
             focusResource: resource,
@@ -2383,10 +3159,11 @@ export var ValidationResult;
             propertySchema: ValidationResult.schema.properties.value,
             typeFromRdfResourceValues: $maybeFromRdfResourceValues(($termFromRdfResourceValues)),
         }),
-    }).chain((properties) => ValidationResult.create(properties)));
+    }).chain((properties) => ValidationResult.create(properties));
     ValidationResult.$toString = (_validationResult) => `ValidationResult(${JSON.stringify(ValidationResult.toStringRecord(_validationResult))})`;
     ValidationResult.create = (parameters) => $sequenceRecord({
         $identifier: $convertToIdentifierProperty(parameters.$identifier, parameters.$defaultNamespace),
+        $type: Right("ValidationResult"),
         details: $convertToScalarSet($identityConversionFunction)(parameters.details, parameters.$defaultNamespace).chain((value) => $validateArray($identityValidationFunction)(ValidationResult.schema.properties.details.type, value)),
         focusNode: Either.of(parameters.focusNode),
         message: $convertToMaybe($identityConversionFunction)(parameters.message, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(ValidationResult.schema.properties.message.type, value)),
@@ -2395,16 +3172,8 @@ export var ValidationResult;
         sourceConstraintComponent: $convertToIri(parameters.sourceConstraintComponent, parameters.$defaultNamespace),
         sourceShape: $convertToMaybe($convertToIdentifier)(parameters.sourceShape, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(ValidationResult.schema.properties.sourceShape.type, value)),
         value: $convertToMaybe($identityConversionFunction)(parameters.value, parameters.$defaultNamespace).chain((value) => $validateMaybe($identityValidationFunction)(ValidationResult.schema.properties.value.type, value)),
-    })
-        .map((properties) => ({
-        ...properties,
-        $type: "ValidationResult",
-    }))
-        .map((object) => $monkeyPatchObject(object, { $toString: ValidationResult.$toString }));
-    function createUnsafe(parameters) {
-        return ValidationResult.create(parameters).unsafeCoerce();
-    }
-    ValidationResult.createUnsafe = createUnsafe;
+    }).map((object) => $monkeyPatchObject(object, { $toString: ValidationResult.$toString }));
+    ValidationResult.createUnsafe = (parameters) => ValidationResult.create(parameters).unsafeCoerce();
     ValidationResult.fromRdfResource = $wrap_FromRdfResourceFunction(ValidationResult._fromRdfResource);
     ValidationResult.fromRdfResourceValues = (values, options) => values.chainMap((value) => value
         .toResource()
@@ -2412,7 +3181,6 @@ export var ValidationResult;
     let Identifier;
     (function (Identifier) {
         Identifier.parse = $parseIdentifier;
-        Identifier.stringify = NTriplesTerm.stringify;
     })(Identifier = ValidationResult.Identifier || (ValidationResult.Identifier = {}));
     ValidationResult.isValidationResult = (object) => object.$type === "ValidationResult";
     ValidationResult.schema = {
@@ -2428,7 +3196,6 @@ export var ValidationResult;
                     dataFactory.namedNode("http://www.w3.org/ns/shacl#ValidationResult"),
                 ],
             },
-            $type: { kind: "Discriminant", value: "ValidationResult" },
             details: {
                 kind: "Shacl",
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#detail"),
@@ -2453,7 +3220,7 @@ export var ValidationResult;
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#resultMessage"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "String" },
+                    itemType: { kind: "String", datatype: $xsd_string },
                 },
             },
             path: {
@@ -2521,29 +3288,76 @@ export var Shape;
         ...options,
         ignoreRdfType: false,
     }));
-    Shape.fromRdfResourceValues = ((values, options) => values.chainMap((value) => {
-        const valueAsValues = value.toValues();
-        return NodeShape.fromRdfResourceValues(valueAsValues, {
-            ...options,
-            ignoreRdfType: false,
-            schema: options.schema.members["NodeShape"].type,
-        })
-            .altLazy(() => PropertyShape.fromRdfResourceValues(valueAsValues, {
-            ...options,
-            ignoreRdfType: false,
-            schema: options.schema.members["PropertyShape"].type,
-        }))
-            .chain((values) => values.head());
-    }));
+    Shape.fromRdfResourceValues = (inputValues, options) => {
+        const memberInputValues = Array.from({ length: 2 }).map(() => Resource.Values.empty({
+            focusResource: inputValues.focusResource,
+            propertyPath: inputValues.propertyPath,
+        }));
+        for (const inputValue of inputValues) {
+            const inputValueAsValues = inputValue.toValues();
+            let memberOutputValuesEither;
+            for (let memberI = 0; memberI < 2; memberI++) {
+                if (memberI === 0) {
+                    memberOutputValuesEither = NodeShape.fromRdfResourceValues(inputValueAsValues, {
+                        ...options,
+                        ignoreRdfType: false,
+                        schema: options.schema.members["NodeShape"].type,
+                    });
+                    if (memberOutputValuesEither.isRight()) {
+                        memberInputValues[memberI] =
+                            memberInputValues[memberI].concat(inputValue);
+                        break;
+                    }
+                }
+                else if (memberI === 1) {
+                    memberOutputValuesEither = PropertyShape.fromRdfResourceValues(inputValueAsValues, {
+                        ...options,
+                        ignoreRdfType: false,
+                        schema: options.schema.members["PropertyShape"].type,
+                    });
+                    if (memberOutputValuesEither.isRight()) {
+                        memberInputValues[memberI] =
+                            memberInputValues[memberI].concat(inputValue);
+                        break;
+                    }
+                }
+            }
+            if (memberOutputValuesEither.isLeft()) {
+                return memberOutputValuesEither;
+            }
+        }
+        let collectedOutputValues = Resource.Values.empty({
+            focusResource: inputValues.focusResource,
+            propertyPath: inputValues.propertyPath,
+        });
+        for (let memberI = 0; memberI < 2; memberI++) {
+            if (memberInputValues[memberI].length === 0) {
+                continue;
+            }
+            switch (memberI) {
+                case 0:
+                    collectedOutputValues = collectedOutputValues.concat(...NodeShape.fromRdfResourceValues(memberInputValues[memberI], {
+                        ...options,
+                        ignoreRdfType: false,
+                        schema: options.schema.members["NodeShape"].type,
+                    }).unsafeCoerce());
+                    break;
+                case 1:
+                    collectedOutputValues = collectedOutputValues.concat(...PropertyShape.fromRdfResourceValues(memberInputValues[memberI], {
+                        ...options,
+                        ignoreRdfType: false,
+                        schema: options.schema.members["PropertyShape"].type,
+                    }).unsafeCoerce());
+                    break;
+            }
+        }
+        return Right(collectedOutputValues);
+    };
     let Identifier;
     (function (Identifier) {
         Identifier.parse = $parseIdentifier;
-        Identifier.stringify = NTriplesTerm.stringify;
     })(Identifier = Shape.Identifier || (Shape.Identifier = {}));
-    function isShape(object) {
-        return (NodeShape.isNodeShape(object) || PropertyShape.isPropertyShape(object));
-    }
-    Shape.isShape = isShape;
+    Shape.isShape = (object) => NodeShape.isNodeShape(object) || PropertyShape.isPropertyShape(object);
     Shape.schema = {
         kind: "ObjectDiscriminatedUnion",
         members: {
@@ -2572,10 +3386,10 @@ export var Shape;
             },
             comment: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
+                path: $rdfs_comment,
                 type: {
                     kind: "Option",
-                    itemType: { kind: "String" },
+                    itemType: { kind: "String", datatype: $xsd_string },
                 },
             },
             datatype: {
@@ -2588,7 +3402,7 @@ export var Shape;
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#deactivated"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "Boolean" },
+                    itemType: { kind: "Boolean", datatype: $xsd_boolean },
                 },
             },
             flags: {
@@ -2596,7 +3410,7 @@ export var Shape;
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#flags"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "String" },
+                    itemType: { kind: "String", datatype: $xsd_string },
                 },
             },
             hasValues: {
@@ -2612,8 +3426,8 @@ export var Shape;
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#ignore"),
                 type: {
                     kind: "DefaultValue",
-                    itemType: { kind: "Boolean" },
-                    defaultValue: dataFactory.literal("false", $RdfVocabularies.xsd.boolean),
+                    itemType: { kind: "Boolean", datatype: $xsd_boolean },
+                    defaultValue: dataFactory.literal("false", $xsd_boolean),
                 },
             },
             in_: {
@@ -2632,7 +3446,7 @@ export var Shape;
             },
             isDefinedBy: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#isDefinedBy"),
+                path: $rdfs_isDefinedBy,
                 type: {
                     kind: "Option",
                     itemType: { kind: "Identifier" },
@@ -2640,10 +3454,10 @@ export var Shape;
             },
             label: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#label"),
+                path: $rdfs_label,
                 type: {
                     kind: "Option",
-                    itemType: { kind: "String" },
+                    itemType: { kind: "String", datatype: $xsd_string },
                 },
             },
             languageIn: {
@@ -2653,7 +3467,7 @@ export var Shape;
                     kind: "Option",
                     itemType: {
                         kind: "List",
-                        itemType: { kind: "String" },
+                        itemType: { kind: "String", datatype: $xsd_string },
                     },
                 },
             },
@@ -2678,7 +3492,7 @@ export var Shape;
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxLength"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "BigInt" },
+                    itemType: { kind: "BigInt", datatype: $xsd_integer },
                 },
             },
             message: {
@@ -2686,7 +3500,7 @@ export var Shape;
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#message"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "String" },
+                    itemType: { kind: "String", datatype: $xsd_string },
                 },
             },
             minExclusive: {
@@ -2710,7 +3524,7 @@ export var Shape;
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minLength"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "BigInt" },
+                    itemType: { kind: "BigInt", datatype: $xsd_integer },
                 },
             },
             mutable: {
@@ -2718,7 +3532,7 @@ export var Shape;
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#mutable"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "Boolean" },
+                    itemType: { kind: "Boolean", datatype: $xsd_boolean },
                 },
             },
             node: {
@@ -2771,7 +3585,7 @@ export var Shape;
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#pattern"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "String" },
+                    itemType: { kind: "String", datatype: $xsd_string },
                 },
             },
             severity: {
@@ -2791,7 +3605,7 @@ export var Shape;
                 path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#name"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "String" },
+                    itemType: { kind: "String", datatype: $xsd_string },
                 },
             },
             targetClasses: {
@@ -2839,10 +3653,20 @@ export var $Object;
                 return NodeShape.$toString(object);
             case "Ontology":
                 return Ontology.$toString(object);
+            case "Operation":
+                return Operation.$toString(object);
+            case "OperationError":
+                return OperationError.$toString(object);
+            case "OperationErrorHttpBinding":
+                return OperationErrorHttpBinding.$toString(object);
+            case "OperationHttpBinding":
+                return OperationHttpBinding.$toString(object);
             case "PropertyGroup":
                 return PropertyGroup.$toString(object);
             case "PropertyShape":
                 return PropertyShape.$toString(object);
+            case "Service":
+                return Service.$toString(object);
             case "ValidationReport":
                 return ValidationReport.$toString(object);
             case "ValidationResult":