@shaclmate/compiler 4.0.41 → 4.0.42

package/dist/input/generated.js

@@ -4,6 +4,16 @@ import { LiteralFactory } from "@rdfx/literal";
 import { PropertyPath as RdfxResourcePropertyPath, Resource, ResourceSet, } from "@rdfx/resource";
 import { NTriplesIdentifier, NTriplesTerm } 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
+        ? value.toBigInt(options.schema.in)
+        : value.toBigInt()));
+}
+function $booleanFromRdfResourceValues(values, options) {
+    return $termLikeFromRdfResourceValues(values, options).chain((values) => values.chainMap((value) => options.schema.in
+        ? value.toBoolean(options.schema.in)
+        : value.toBoolean()));
+}
 /**
  * Remove undefined values from a record.
  */
@@ -99,6 +109,16 @@ function $convertWithDefaultValue(convertToItem, defaultValue) {
         return convertToItem(value);
     };
 }
+function $defaultValueFromRdfResourceValues(itemFromRdfResourceValues) {
+    return (values, options) => itemFromRdfResourceValues(values.length > 0
+        ? values
+        : new Resource.Value({
+            dataFactory: dataFactory,
+            focusResource: options.focusResource,
+            propertyPath: options.propertyPath,
+            term: options.schema.defaultValue,
+        }).toValues(), { ...options, schema: options.schema.itemType });
+}
 function $ensureRdfResourceType(resource, types, options) {
     return resource
         .value($RdfVocabularies.rdf.type, options)
@@ -127,27 +147,13 @@ export var $EqualsResult;
     }
     $EqualsResult.fromBooleanEqualsResult = fromBooleanEqualsResult;
 })($EqualsResult || ($EqualsResult = {}));
-function $fromRdfPreferredLanguages(values, preferredLanguages) {
-    if (!preferredLanguages || preferredLanguages.length === 0) {
-        return Right(values);
-    }
-    // Return all literals for the first preferredLanguage, then all literals for the second preferredLanguage, etc.
-    // Within a preferredLanguage the literals may be in any order.
-    const filteredValues = [];
-    for (const preferredLanguage of preferredLanguages) {
-        for (const value of values) {
-            value.toLiteral().ifRight((literal) => {
-                if (literal.language === preferredLanguage) {
-                    filteredValues.push(value);
-                }
-            });
-        }
-    }
-    return Right(Resource.Values.fromArray({
-        focusResource: values.focusResource,
-        propertyPath: values.propertyPath,
-        values: filteredValues,
-    }));
+function $floatFromRdfResourceValues(values, options) {
+    return $termLikeFromRdfResourceValues(values, options).chain((values) => values.chainMap((value) => options.schema.in
+        ? value.toFloat(options.schema.in)
+        : value.toFloat()));
+}
+function $identifierFromRdfResourceValues(values, options) {
+    return $termLikeFromRdfResourceValues(values, options).chain((values) => values.chainMap((value) => value.toIdentifier()));
 }
 function $identityConversionFunction(value) {
     return Either.of(value);
@@ -155,7 +161,37 @@ function $identityConversionFunction(value) {
 function $identityValidationFunction(_schema, value) {
     return Either.of(value);
 }
+function $iriFromRdfResourceValues(values, options) {
+    return $termLikeFromRdfResourceValues(values, options).chain((values) => values.chainMap((value) => options.schema.in
+        ? value.toIri(options.schema.in)
+        : value.toIri()));
+}
+function $listFromRdfResourceValues(itemFromRdfResourceValues) {
+    return (values, options) => values
+        .chainMap((value) => value.toList({ graph: options.graph })) // Resource.Values<Resource.Value> to Resource.Values<Resource.Values>;
+        .chain((valueLists) => valueLists.chainMap((valueList) => itemFromRdfResourceValues(Resource.Values.fromArray({
+        focusResource: options.focusResource,
+        propertyPath: options.propertyPath,
+        values: valueList.toArray(),
+    }), { ...options, schema: options.schema.itemType }))) // Resource.Values<Resource.Values> to Resource.Values<item type arrays>
+        .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()));
+}
+function $maybeFromRdfResourceValues(itemFromRdfResourceValues) {
+    return (values, options) => itemFromRdfResourceValues(values, {
+        ...options,
+        schema: options.schema.itemType,
+    }).map((values) => values.length > 0
+        ? values.map((value) => Maybe.of(value))
+        : Resource.Values.fromValue({
+            focusResource: options.focusResource,
+            propertyPath: options.propertyPath,
+            value: Maybe.empty(),
+        }));
+}
 function $monkeyPatchObject(obj, methods) {
     if (methods.toJson &&
         (!globalThis.Object.prototype.hasOwnProperty.call(obj, "toJSON") ||
@@ -179,50 +215,47 @@ const $parseIdentifier = NTriplesIdentifier.parser(dataFactory);
 export var $PropertyPath;
 (function ($PropertyPath) {
     $PropertyPath.fromRdfResource = RdfxResourcePropertyPath.fromResource;
-    $PropertyPath.fromRdfResourceValues = (values, options) => values.chain((values) => values.chainMap((value) => value
+    $PropertyPath.fromRdfResourceValues = (values, options) => values.chainMap((value) => value
         .toResource()
-        .chain((resource) => $PropertyPath.fromRdfResource(resource, options))));
+        .chain((resource) => $PropertyPath.fromRdfResource(resource, options)));
     $PropertyPath.schema = {};
     $PropertyPath.toRdfResource = RdfxResourcePropertyPath.toResource;
     $PropertyPath.$toString = RdfxResourcePropertyPath.toString;
 })($PropertyPath || ($PropertyPath = {}));
 var $RdfVocabularies;
 (function ($RdfVocabularies) {
-    let rdf;
-    (function (rdf) {
-        rdf.first = dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#first");
-        rdf.nil = dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#nil");
-        rdf.rest = dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#rest");
-        rdf.subject = dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#subject");
-        rdf.type = dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#type");
-    })(rdf = $RdfVocabularies.rdf || ($RdfVocabularies.rdf = {}));
-    let rdfs;
-    (function (rdfs) {
-        rdfs.subClassOf = dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#subClassOf");
-    })(rdfs = $RdfVocabularies.rdfs || ($RdfVocabularies.rdfs = {}));
-    let xsd;
-    (function (xsd) {
-        xsd.boolean = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#boolean");
-        xsd.byte = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#byte");
-        xsd.date = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#date");
-        xsd.dateTime = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#dateTime");
-        xsd.decimal = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#decimal");
-        xsd.double = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#double");
-        xsd.float = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#float");
-        xsd.int = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#int");
-        xsd.integer = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#integer");
-        xsd.long = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#long");
-        xsd.negativeInteger = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#negativeInteger");
-        xsd.nonNegativeInteger = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#nonNegativeInteger");
-        xsd.nonPositiveInteger = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#nonPositiveInteger");
-        xsd.positiveInteger = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#positiveInteger");
-        xsd.short = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#short");
-        xsd.string = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#string");
-        xsd.unsignedByte = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#unsignedByte");
-        xsd.unsignedInt = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#unsignedInt");
-        xsd.unsignedLong = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#unsignedLong");
-        xsd.unsignedShort = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#unsignedShort");
-    })(xsd = $RdfVocabularies.xsd || ($RdfVocabularies.xsd = {}));
+    $RdfVocabularies.rdf = {
+        first: dataFactory.namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#first"),
+        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"),
+        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 = {}));
 function $sequenceRecord(record) {
     const result = {};
@@ -235,8 +268,26 @@ function $sequenceRecord(record) {
     }
     return Right(result);
 }
-function $shaclPropertyFromRdf({ graph, propertySchema, resource, typeFromRdf, }) {
-    return typeFromRdf(Right(resource.values(propertySchema.path, { graph, unique: true }))).chain((values) => values.head());
+function $setFromRdfResourceValues(itemFromRdfResourceValues) {
+    return (values, options) => itemFromRdfResourceValues(values, {
+        ...options,
+        schema: options.schema.itemType,
+    })
+        .map((values) => values.toArray())
+        .map((valuesArray) => Resource.Values.fromValue({
+        focusResource: options.focusResource,
+        propertyPath: options.propertyPath,
+        value: valuesArray,
+    }));
+}
+function $shaclPropertyFromRdf({ focusResource, graph, propertySchema, typeFromRdfResourceValues, ...otherParameters }) {
+    return typeFromRdfResourceValues(focusResource.values(propertySchema.path, { graph, unique: true }), {
+        ...otherParameters,
+        focusResource,
+        graph,
+        propertyPath: propertySchema.path,
+        schema: propertySchema.type,
+    }).chain((values) => values.head());
 }
 /**
  * Compare two values for strict equality (===), returning an $EqualsResult rather than a boolean.
@@ -244,6 +295,84 @@ function $shaclPropertyFromRdf({ graph, propertySchema, resource, typeFromRdf, }
 function $strictEquals(left, right) {
     return $EqualsResult.fromBooleanEqualsResult(left, right, left === right);
 }
+function $stringFromRdfResourceValues(values, options) {
+    return $termLikeFromRdfResourceValues(values, options).chain((values) => values.chainMap((value) => options.schema.in
+        ? value.toString(options.schema.in)
+        : value.toString()));
+}
+function $termFromRdfResourceValues(values, options) {
+    const { focusResource, propertyPath, schema } = options;
+    return $termLikeFromRdfResourceValues(values, options).chain((values) => values.chainMap((value) => value.toTerm().chain((term) => {
+        if (schema.in &&
+            schema.in.length > 0 &&
+            !schema.in.some((in_) => in_.equals(term))) {
+            return Left(new Resource.MistypedTermValueError({
+                actualValue: term,
+                expectedValueType: "Term in",
+                focusResource,
+                propertyPath,
+            }));
+        }
+        if (!schema.types.some((type) => term.termType === type)) {
+            return Left(new Resource.MistypedTermValueError({
+                actualValue: term,
+                expectedValueType: "Term types",
+                focusResource,
+                propertyPath,
+            }));
+        }
+        return Right(term);
+    })));
+}
+const $termLikeFromRdfResourceValues = (values, { preferredLanguages, schema: { hasValues, languageIn } }) => {
+    let chain = Either.of(values);
+    if (hasValues && hasValues.length > 0) {
+        chain = chain.chain((values) => Either.sequence(hasValues.map((hasValue) => values.find((value) => value.term.equals(hasValue)))).map(() => values));
+    }
+    if (languageIn && languageIn.length > 0) {
+        chain = chain.chain((values) => values.chainMap((value) => value.toLiteral().chain((literal) => languageIn.includes(literal.language)
+            ? Right(value)
+            : Left(new Resource.MistypedTermValueError({
+                actualValue: literal,
+                expectedValueType: "Literal",
+                focusResource: value.focusResource,
+                propertyPath: value.propertyPath,
+            })))));
+    }
+    if (preferredLanguages && preferredLanguages.length > 0) {
+        chain = chain.chain((values) => {
+            const literals = [];
+            const literalValues = [];
+            const nonLiteralValues = [];
+            for (const value of values) {
+                const term = value.toTerm().unsafeCoerce();
+                if (term.termType === "Literal") {
+                    literals.push(term);
+                    literalValues.push(value);
+                }
+                else {
+                    nonLiteralValues.push(value);
+                }
+            }
+            // Return all literals for the first preferredLanguage, then all literals for the second preferredLanguage, etc.
+            // Within a preferredLanguage the literals may be in any order.
+            const preferredLanguageLiteralValues = [];
+            for (const preferredLanguage of preferredLanguages) {
+                for (let literalI = 0; literalI < literals.length; literalI++) {
+                    if (literals[literalI].language === preferredLanguage) {
+                        preferredLanguageLiteralValues.push(literalValues[literalI]);
+                    }
+                }
+            }
+            return Right(Resource.Values.fromArray({
+                focusResource: values.focusResource,
+                propertyPath: values.propertyPath,
+                values: nonLiteralValues.concat(preferredLanguageLiteralValues),
+            }));
+        });
+    }
+    return chain;
+};
 function $validateArray(validateItem, _readonly) {
     return (schema, valueArray) => {
         if (schema.minCount !== undefined && valueArray.length < schema.minCount) {
@@ -288,901 +417,471 @@ function $wrap_ToRdfResourceFunction(_toRdfResourceFunction) {
         return resource;
     };
 }
-export var PropertyShape;
-(function (PropertyShape) {
-    function create(parameters) {
-        return $sequenceRecord({
-            $identifier: $convertToIdentifierProperty(parameters.$identifier),
-            and: $convertToMaybe($convertToList($convertToIdentifier, true))(parameters.and).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(PropertyShape.schema.properties.and.type, value)),
-            classes: $convertToScalarSet(($convertToIri), true)(parameters.classes).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.classes.type, value)),
-            comment: $convertToMaybe($identityConversionFunction)(parameters.comment).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.comment.type, value)),
-            datatype: $convertToMaybe(($convertToIri))(parameters.datatype).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.datatype.type, value)),
-            deactivated: $convertToMaybe($identityConversionFunction)(parameters.deactivated).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.deactivated.type, value)),
-            defaultValue: $convertToMaybe($identityConversionFunction)(parameters.defaultValue).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.defaultValue.type, value)),
-            description: $convertToMaybe($identityConversionFunction)(parameters.description).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.description.type, value)),
-            disjoint: $convertToScalarSet(($convertToIri), true)(parameters.disjoint).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.disjoint.type, value)),
-            display: $convertWithDefaultValue($identityConversionFunction, false)(parameters.display),
-            equals: $convertToScalarSet(($convertToIri), true)(parameters.equals).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.equals.type, value)),
-            flags: $convertToMaybe($identityConversionFunction)(parameters.flags).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.flags.type, value)),
-            groups: $convertToScalarSet($convertToIdentifier, true)(parameters.groups).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.groups.type, value)),
-            hasValues: $convertToScalarSet($identityConversionFunction, true)(parameters.hasValues).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.hasValues.type, value)),
-            in_: $convertToMaybe($convertToList($identityConversionFunction, true))(parameters.in_).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(PropertyShape.schema.properties.in_.type, value)),
-            isDefinedBy: $convertToMaybe($convertToIdentifier)(parameters.isDefinedBy).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.isDefinedBy.type, value)),
-            label: $convertToMaybe($identityConversionFunction)(parameters.label).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.label.type, value)),
-            languageIn: $convertToMaybe($convertToList($identityConversionFunction, true))(parameters.languageIn).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(PropertyShape.schema.properties.languageIn.type, value)),
-            lessThan: $convertToScalarSet(($convertToIri), true)(parameters.lessThan).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.lessThan.type, value)),
-            lessThanOrEquals: $convertToScalarSet(($convertToIri), true)(parameters.lessThanOrEquals).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.lessThanOrEquals.type, value)),
-            maxCount: $convertToMaybe($identityConversionFunction)(parameters.maxCount).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.maxCount.type, value)),
-            maxExclusive: $convertToMaybe($convertToLiteral)(parameters.maxExclusive).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.maxExclusive.type, value)),
-            maxInclusive: $convertToMaybe($convertToLiteral)(parameters.maxInclusive).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.maxInclusive.type, value)),
-            maxLength: $convertToMaybe($identityConversionFunction)(parameters.maxLength).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.maxLength.type, value)),
-            message: $convertToMaybe($identityConversionFunction)(parameters.message).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.message.type, value)),
-            minCount: $convertToMaybe($identityConversionFunction)(parameters.minCount).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.minCount.type, value)),
-            minExclusive: $convertToMaybe($convertToLiteral)(parameters.minExclusive).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.minExclusive.type, value)),
-            minInclusive: $convertToMaybe($convertToLiteral)(parameters.minInclusive).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.minInclusive.type, value)),
-            minLength: $convertToMaybe($identityConversionFunction)(parameters.minLength).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.minLength.type, value)),
-            mutable: $convertToMaybe($identityConversionFunction)(parameters.mutable).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.mutable.type, value)),
-            name: $convertToMaybe($identityConversionFunction)(parameters.name).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.name.type, value)),
-            node: $convertToMaybe($convertToIdentifier)(parameters.node).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.node.type, value)),
-            nodeKind: $convertToMaybe(($convertToIri))(parameters.nodeKind).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.nodeKind.type, value)),
-            not: $convertToScalarSet($convertToIdentifier, true)(parameters.not).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.not.type, value)),
-            or: $convertToMaybe($convertToList($convertToIdentifier, true))(parameters.or).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(PropertyShape.schema.properties.or.type, value)),
-            order: $convertToMaybe($identityConversionFunction)(parameters.order).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.order.type, value)),
-            path: Either.of(parameters.path),
-            pattern: $convertToMaybe($identityConversionFunction)(parameters.pattern).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.pattern.type, value)),
-            qualifiedMaxCount: $convertToMaybe($identityConversionFunction)(parameters.qualifiedMaxCount).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.qualifiedMaxCount.type, value)),
-            qualifiedMinCount: $convertToMaybe($identityConversionFunction)(parameters.qualifiedMinCount).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.qualifiedMinCount.type, value)),
-            qualifiedValueShape: $convertToMaybe($convertToIdentifier)(parameters.qualifiedValueShape).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.qualifiedValueShape.type, value)),
-            qualifiedValueShapesDisjoint: $convertToMaybe($identityConversionFunction)(parameters.qualifiedValueShapesDisjoint).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.qualifiedValueShapesDisjoint.type, value)),
-            resolve: $convertToMaybe($convertToIdentifier)(parameters.resolve).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.resolve.type, value)),
-            severity: $convertToMaybe(($convertToIri))(parameters.severity).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.severity.type, value)),
-            shaclmateName: $convertToMaybe($identityConversionFunction)(parameters.shaclmateName).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.shaclmateName.type, value)),
-            targetClasses: $convertToScalarSet(($convertToIri), true)(parameters.targetClasses).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.targetClasses.type, value)),
-            targetNodes: $convertToScalarSet($identityConversionFunction, true)(parameters.targetNodes).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.targetNodes.type, value)),
-            targetObjectsOf: $convertToScalarSet(($convertToIri), true)(parameters.targetObjectsOf).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.targetObjectsOf.type, value)),
-            targetSubjectsOf: $convertToScalarSet(($convertToIri), true)(parameters.targetSubjectsOf).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.targetSubjectsOf.type, value)),
-            uniqueLang: $convertToMaybe($identityConversionFunction)(parameters.uniqueLang).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.uniqueLang.type, value)),
-            xone: $convertToMaybe($convertToList($convertToIdentifier, true))(parameters.xone).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(PropertyShape.schema.properties.xone.type, value)),
-        }).map((properties) => $monkeyPatchObject({ ...properties, $type: "PropertyShape" }, { $toString }));
-    }
-    PropertyShape.create = create;
+export var NodeShape;
+(function (NodeShape) {
+    NodeShape.create = (parameters) => $sequenceRecord({
+        $identifier: $convertToIdentifierProperty(parameters?.$identifier),
+        and: $convertToMaybe($convertToList($convertToIdentifier, true))(parameters?.and).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(NodeShape.schema.properties.and.type, value)),
+        classes: $convertToScalarSet(($convertToIri), true)(parameters?.classes).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.classes.type, value)),
+        closed: $convertToMaybe($identityConversionFunction)(parameters?.closed).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.closed.type, value)),
+        comment: $convertToMaybe($identityConversionFunction)(parameters?.comment).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.comment.type, value)),
+        datatype: $convertToMaybe(($convertToIri))(parameters?.datatype).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.datatype.type, value)),
+        deactivated: $convertToMaybe($identityConversionFunction)(parameters?.deactivated).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.deactivated.type, value)),
+        discriminantValue: $convertToMaybe($identityConversionFunction)(parameters?.discriminantValue).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.discriminantValue.type, value)),
+        extern: $convertToMaybe($identityConversionFunction)(parameters?.extern).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.extern.type, value)),
+        flags: $convertToMaybe($identityConversionFunction)(parameters?.flags).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.flags.type, value)),
+        fromRdfType: $convertToMaybe(($convertToIri))(parameters?.fromRdfType).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.fromRdfType.type, value)),
+        hasValues: $convertToScalarSet($identityConversionFunction, true)(parameters?.hasValues).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.hasValues.type, value)),
+        ignoredProperties: $convertToMaybe($convertToList(($convertToIri), true))(parameters?.ignoredProperties).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(NodeShape.schema.properties.ignoredProperties.type, value)),
+        in_: $convertToMaybe($convertToList($identityConversionFunction, true))(parameters?.in_).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(NodeShape.schema.properties.in_.type, value)),
+        isDefinedBy: $convertToMaybe($convertToIdentifier)(parameters?.isDefinedBy).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.isDefinedBy.type, value)),
+        label: $convertToMaybe($identityConversionFunction)(parameters?.label).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.label.type, value)),
+        languageIn: $convertToMaybe($convertToList($identityConversionFunction, true))(parameters?.languageIn).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(NodeShape.schema.properties.languageIn.type, value)),
+        maxExclusive: $convertToMaybe($convertToLiteral)(parameters?.maxExclusive).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.maxExclusive.type, value)),
+        maxInclusive: $convertToMaybe($convertToLiteral)(parameters?.maxInclusive).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.maxInclusive.type, value)),
+        maxLength: $convertToMaybe($identityConversionFunction)(parameters?.maxLength).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.maxLength.type, value)),
+        message: $convertToMaybe($identityConversionFunction)(parameters?.message).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.message.type, value)),
+        minExclusive: $convertToMaybe($convertToLiteral)(parameters?.minExclusive).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.minExclusive.type, value)),
+        minInclusive: $convertToMaybe($convertToLiteral)(parameters?.minInclusive).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.minInclusive.type, value)),
+        minLength: $convertToMaybe($identityConversionFunction)(parameters?.minLength).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.minLength.type, value)),
+        mutable: $convertToMaybe($identityConversionFunction)(parameters?.mutable).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.mutable.type, value)),
+        node: $convertToMaybe($convertToIdentifier)(parameters?.node).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.node.type, value)),
+        nodeKind: $convertToMaybe(($convertToIri))(parameters?.nodeKind).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.nodeKind.type, value)),
+        not: $convertToScalarSet($convertToIdentifier, true)(parameters?.not).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.not.type, value)),
+        or: $convertToMaybe($convertToList($convertToIdentifier, true))(parameters?.or).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(NodeShape.schema.properties.or.type, value)),
+        pattern: $convertToMaybe($identityConversionFunction)(parameters?.pattern).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.pattern.type, value)),
+        properties: $convertToScalarSet($convertToIdentifier, true)(parameters?.properties).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.properties.type, value)),
+        rdfType: $convertToMaybe(($convertToIri))(parameters?.rdfType).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.rdfType.type, value)),
+        severity: $convertToMaybe(($convertToIri))(parameters?.severity).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.severity.type, value)),
+        shaclmateName: $convertToMaybe($identityConversionFunction)(parameters?.shaclmateName).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.shaclmateName.type, value)),
+        subClassOf: $convertToScalarSet(($convertToIri), true)(parameters?.subClassOf).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.subClassOf.type, value)),
+        targetClasses: $convertToScalarSet(($convertToIri), true)(parameters?.targetClasses).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.targetClasses.type, value)),
+        targetNodes: $convertToScalarSet($identityConversionFunction, true)(parameters?.targetNodes).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.targetNodes.type, value)),
+        targetObjectsOf: $convertToScalarSet(($convertToIri), true)(parameters?.targetObjectsOf).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.targetObjectsOf.type, value)),
+        targetSubjectsOf: $convertToScalarSet(($convertToIri), true)(parameters?.targetSubjectsOf).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.targetSubjectsOf.type, value)),
+        toRdfTypes: $convertToScalarSet(($convertToIri), true)(parameters?.toRdfTypes).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.toRdfTypes.type, value)),
+        tsImports: $convertToScalarSet($identityConversionFunction, true)(parameters?.tsImports).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.tsImports.type, value)),
+        types: $convertToScalarSet(($convertToIri), true)(parameters?.types).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.types.type, value)),
+        xone: $convertToMaybe($convertToList($convertToIdentifier, true))(parameters?.xone).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(NodeShape.schema.properties.xone.type, value)),
+    })
+        .map((properties) => ({ ...properties, $type: "NodeShape" }))
+        .map((object) => $monkeyPatchObject(object, { $toString: NodeShape.$toString }));
     function createUnsafe(parameters) {
-        return create(parameters).unsafeCoerce();
+        return NodeShape.create(parameters).unsafeCoerce();
     }
-    PropertyShape.createUnsafe = createUnsafe;
+    NodeShape.createUnsafe = createUnsafe;
+    NodeShape._fromRdfResource = ($resource, _$options) => (!_$options.ignoreRdfType
+        ? $ensureRdfResourceType($resource, [NodeShape.schema.fromRdfType], {
+            graph: _$options.graph,
+        })
+        : Right(true)).chain((_rdfTypeCheck) => $sequenceRecord({
+        $identifier: $identifierFromRdfResourceValues(new Resource.Value({
+            dataFactory: dataFactory,
+            focusResource: $resource,
+            propertyPath: $RdfVocabularies.rdf.subject,
+            term: $resource.identifier,
+        }).toValues(), {
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            preferredLanguages: _$options.preferredLanguages,
+            propertyPath: $RdfVocabularies.rdf.subject,
+            schema: NodeShape.schema.properties.$identifier.type,
+        }).chain((values) => values.head()),
+        and: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.and,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues($identifierFromRdfResourceValues)),
+        }),
+        classes: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.classes,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        closed: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.closed,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($booleanFromRdfResourceValues)),
+        }),
+        comment: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.comment,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        datatype: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.datatype,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        deactivated: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.deactivated,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($booleanFromRdfResourceValues)),
+        }),
+        discriminantValue: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.discriminantValue,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        extern: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.extern,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($booleanFromRdfResourceValues)),
+        }),
+        flags: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.flags,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        fromRdfType: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.fromRdfType,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        hasValues: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.hasValues,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($termFromRdfResourceValues)),
+        }),
+        ignoredProperties: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.ignoredProperties,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues(($iriFromRdfResourceValues))),
+        }),
+        in_: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.in_,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues(($termFromRdfResourceValues))),
+        }),
+        isDefinedBy: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.isDefinedBy,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($identifierFromRdfResourceValues),
+        }),
+        label: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.label,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        languageIn: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.languageIn,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues(($stringFromRdfResourceValues))),
+        }),
+        maxExclusive: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.maxExclusive,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($literalFromRdfResourceValues),
+        }),
+        maxInclusive: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.maxInclusive,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($literalFromRdfResourceValues),
+        }),
+        maxLength: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.maxLength,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($bigIntFromRdfResourceValues)),
+        }),
+        message: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.message,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        minExclusive: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.minExclusive,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($literalFromRdfResourceValues),
+        }),
+        minInclusive: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.minInclusive,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($literalFromRdfResourceValues),
+        }),
+        minLength: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.minLength,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($bigIntFromRdfResourceValues)),
+        }),
+        mutable: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.mutable,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($booleanFromRdfResourceValues)),
+        }),
+        node: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.node,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($identifierFromRdfResourceValues),
+        }),
+        nodeKind: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.nodeKind,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        not: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.not,
+            typeFromRdfResourceValues: $setFromRdfResourceValues($identifierFromRdfResourceValues),
+        }),
+        or: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.or,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues($identifierFromRdfResourceValues)),
+        }),
+        pattern: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.pattern,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        properties: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.properties,
+            typeFromRdfResourceValues: $setFromRdfResourceValues($identifierFromRdfResourceValues),
+        }),
+        rdfType: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.rdfType,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        severity: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.severity,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        shaclmateName: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.shaclmateName,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        subClassOf: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.subClassOf,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        targetClasses: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.targetClasses,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        targetNodes: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.targetNodes,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($termFromRdfResourceValues)),
+        }),
+        targetObjectsOf: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.targetObjectsOf,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        targetSubjectsOf: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.targetSubjectsOf,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        toRdfTypes: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.toRdfTypes,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        tsImports: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.tsImports,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        types: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.types,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        xone: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.xone,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues($identifierFromRdfResourceValues)),
+        }),
+    }).chain((properties) => NodeShape.create(properties)));
+    NodeShape.fromRdfResource = $wrap_FromRdfResourceFunction(NodeShape._fromRdfResource);
+    NodeShape.fromRdfResourceValues = (values, options) => values.chainMap((value) => value
+        .toResource()
+        .chain((resource) => NodeShape.fromRdfResource(resource, options)));
     let Identifier;
     (function (Identifier) {
         Identifier.parse = $parseIdentifier;
         Identifier.stringify = NTriplesTerm.stringify;
-    })(Identifier = PropertyShape.Identifier || (PropertyShape.Identifier = {}));
-    PropertyShape._fromRdfResource = ($resource, _$options) => {
-        return (!_$options.ignoreRdfType
-            ? $ensureRdfResourceType($resource, [PropertyShape.fromRdfType], {
-                graph: _$options.graph,
-            })
-            : Right(true)).chain((_rdfTypeCheck) => $sequenceRecord({
-            $identifier: Right(new Resource.Value({
-                dataFactory: dataFactory,
-                focusResource: $resource,
-                propertyPath: $RdfVocabularies.rdf.subject,
-                term: $resource.identifier,
-            }).toValues())
-                .chain((values) => values.chainMap((value) => value.toIdentifier()))
-                .chain((values) => values.head()),
-            and: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.and,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toList({ graph: _$options.graph })))
-                    .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.and.path,
-                    values: valueList.toArray(),
-                })).chain((values) => values.chainMap((value) => value.toIdentifier()))))
-                    .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.and.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            classes: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.classes,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIri()))
-                    .map((values) => values.toArray())
-                    .map((valuesArray) => Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.classes.path,
-                    value: valuesArray,
-                })),
-            }),
-            comment: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.comment,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toString()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.comment.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            datatype: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.datatype,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIri()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.datatype.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            deactivated: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.deactivated,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toBoolean()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.deactivated.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            defaultValue: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.defaultValue,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toTerm().chain((term) => {
-                    switch (term.termType) {
-                        case "NamedNode":
-                        case "Literal":
-                            return Either.of(term);
-                        default:
-                            return Left(new Resource.MistypedTermValueError({
-                                actualValue: term,
-                                expectedValueType: "(NamedNode | Literal)",
-                                focusResource: $resource,
-                                propertyPath: PropertyShape.schema.properties.defaultValue.path,
-                            }));
-                    }
-                })))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.defaultValue.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            description: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.description,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toString()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.description.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            disjoint: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.disjoint,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIri()))
-                    .map((values) => values.toArray())
-                    .map((valuesArray) => Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.disjoint.path,
-                    value: valuesArray,
-                })),
-            }),
-            display: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.display,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .map((values) => values.length > 0
-                    ? values
-                    : new Resource.Value({
-                        dataFactory: dataFactory,
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.display.path,
-                        term: dataFactory.literal("false", $RdfVocabularies.xsd.boolean),
-                    }).toValues())
-                    .chain((values) => values.chainMap((value) => value.toBoolean())),
-            }),
-            equals: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.equals,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIri()))
-                    .map((values) => values.toArray())
-                    .map((valuesArray) => Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.equals.path,
-                    value: valuesArray,
-                })),
-            }),
-            flags: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.flags,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toString()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.flags.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            groups: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.groups,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIdentifier()))
-                    .map((values) => values.toArray())
-                    .map((valuesArray) => Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.groups.path,
-                    value: valuesArray,
-                })),
-            }),
-            hasValues: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.hasValues,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toTerm().chain((term) => {
-                    switch (term.termType) {
-                        case "NamedNode":
-                        case "Literal":
-                            return Either.of(term);
-                        default:
-                            return Left(new Resource.MistypedTermValueError({
-                                actualValue: term,
-                                expectedValueType: "(NamedNode | Literal)",
-                                focusResource: $resource,
-                                propertyPath: PropertyShape.schema.properties.hasValues.path,
-                            }));
-                    }
-                })))
-                    .map((values) => values.toArray())
-                    .map((valuesArray) => Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.hasValues.path,
-                    value: valuesArray,
-                })),
-            }),
-            in_: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.in_,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toList({ graph: _$options.graph })))
-                    .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.in_.path,
-                    values: valueList.toArray(),
-                })).chain((values) => values.chainMap((value) => value.toTerm().chain((term) => {
-                    switch (term.termType) {
-                        case "NamedNode":
-                        case "Literal":
-                            return Either.of(term);
-                        default:
-                            return Left(new Resource.MistypedTermValueError({
-                                actualValue: term,
-                                expectedValueType: "(NamedNode | Literal)",
-                                focusResource: $resource,
-                                propertyPath: PropertyShape.schema.properties.in_.path,
-                            }));
-                    }
-                })))))
-                    .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.in_.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            isDefinedBy: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.isDefinedBy,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIdentifier()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.isDefinedBy.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            label: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.label,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toString()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.label.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            languageIn: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.languageIn,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toList({ graph: _$options.graph })))
-                    .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.languageIn.path,
-                    values: valueList.toArray(),
-                }))
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toString()))))
-                    .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.languageIn.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            lessThan: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.lessThan,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIri()))
-                    .map((values) => values.toArray())
-                    .map((valuesArray) => Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.lessThan.path,
-                    value: valuesArray,
-                })),
-            }),
-            lessThanOrEquals: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.lessThanOrEquals,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIri()))
-                    .map((values) => values.toArray())
-                    .map((valuesArray) => Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.lessThanOrEquals.path,
-                    value: valuesArray,
-                })),
-            }),
-            maxCount: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.maxCount,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toBigInt()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.maxCount.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            maxExclusive: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.maxExclusive,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toLiteral()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.maxExclusive.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            maxInclusive: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.maxInclusive,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toLiteral()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.maxInclusive.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            maxLength: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.maxLength,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toBigInt()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.maxLength.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            message: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.message,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toString()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.message.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            minCount: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.minCount,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toBigInt()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.minCount.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            minExclusive: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.minExclusive,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toLiteral()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.minExclusive.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            minInclusive: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.minInclusive,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toLiteral()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.minInclusive.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            minLength: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.minLength,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toBigInt()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.minLength.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            mutable: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.mutable,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toBoolean()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.mutable.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            name: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.name,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toString()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.name.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            node: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.node,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIdentifier()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.node.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            nodeKind: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.nodeKind,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIri([
-                    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"),
-                ])))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.nodeKind.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            not: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.not,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIdentifier()))
-                    .map((values) => values.toArray())
-                    .map((valuesArray) => Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.not.path,
-                    value: valuesArray,
-                })),
-            }),
-            or: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.or,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toList({ graph: _$options.graph })))
-                    .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.or.path,
-                    values: valueList.toArray(),
-                })).chain((values) => values.chainMap((value) => value.toIdentifier()))))
-                    .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.or.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            order: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.order,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toFloat()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.order.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            path: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.path,
-                typeFromRdf: (resourceValues) => $PropertyPath.fromRdfResourceValues(resourceValues, {
-                    context: _$options.context,
-                    graph: _$options.graph,
-                    preferredLanguages: _$options.preferredLanguages,
-                    resource: $resource,
-                    ignoreRdfType: true,
-                    propertyPath: PropertyShape.schema.properties.path.path,
-                }),
-            }),
-            pattern: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.pattern,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toString()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.pattern.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            qualifiedMaxCount: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.qualifiedMaxCount,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toBigInt()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.qualifiedMaxCount.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            qualifiedMinCount: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.qualifiedMinCount,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toBigInt()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.qualifiedMinCount.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            qualifiedValueShape: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.qualifiedValueShape,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIdentifier()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.qualifiedValueShape
-                            .path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            qualifiedValueShapesDisjoint: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.qualifiedValueShapesDisjoint,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toBoolean()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties
-                            .qualifiedValueShapesDisjoint.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            resolve: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.resolve,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIdentifier()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.resolve.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            severity: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.severity,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIri([
-                    dataFactory.namedNode("http://www.w3.org/ns/shacl#Info"),
-                    dataFactory.namedNode("http://www.w3.org/ns/shacl#Warning"),
-                    dataFactory.namedNode("http://www.w3.org/ns/shacl#Violation"),
-                ])))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.severity.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            shaclmateName: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.shaclmateName,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toString()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.shaclmateName.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            targetClasses: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.targetClasses,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIri()))
-                    .map((values) => values.toArray())
-                    .map((valuesArray) => Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.targetClasses.path,
-                    value: valuesArray,
-                })),
-            }),
-            targetNodes: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.targetNodes,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toTerm().chain((term) => {
-                    switch (term.termType) {
-                        case "NamedNode":
-                        case "Literal":
-                            return Either.of(term);
-                        default:
-                            return Left(new Resource.MistypedTermValueError({
-                                actualValue: term,
-                                expectedValueType: "(NamedNode | Literal)",
-                                focusResource: $resource,
-                                propertyPath: PropertyShape.schema.properties.targetNodes.path,
-                            }));
-                    }
-                })))
-                    .map((values) => values.toArray())
-                    .map((valuesArray) => Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.targetNodes.path,
-                    value: valuesArray,
-                })),
-            }),
-            targetObjectsOf: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.targetObjectsOf,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIri()))
-                    .map((values) => values.toArray())
-                    .map((valuesArray) => Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.targetObjectsOf.path,
-                    value: valuesArray,
-                })),
-            }),
-            targetSubjectsOf: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.targetSubjectsOf,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIri()))
-                    .map((values) => values.toArray())
-                    .map((valuesArray) => Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.targetSubjectsOf.path,
-                    value: valuesArray,
-                })),
-            }),
-            uniqueLang: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.uniqueLang,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toBoolean()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.uniqueLang.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            xone: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.xone,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toList({ graph: _$options.graph })))
-                    .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.xone.path,
-                    values: valueList.toArray(),
-                })).chain((values) => values.chainMap((value) => value.toIdentifier()))))
-                    .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.xone.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-        }).chain((properties) => create(properties)));
-    };
-    PropertyShape.fromRdfResource = $wrap_FromRdfResourceFunction(PropertyShape._fromRdfResource);
-    PropertyShape.fromRdfResourceValues = (values, options) => values.chain((values) => values.chainMap((value) => value
-        .toResource()
-        .chain((resource) => PropertyShape.fromRdfResource(resource, options))));
-    PropertyShape.fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape");
-    function isPropertyShape(object) {
-        switch (object.$type) {
-            case "PropertyShape":
-                return true;
-            default:
-                return false;
-        }
+    })(Identifier = NodeShape.Identifier || (NodeShape.Identifier = {}));
+    function isNodeShape(object) {
+        return object.$type === "NodeShape";
     }
-    PropertyShape.isPropertyShape = isPropertyShape;
-    PropertyShape.schema = {
+    NodeShape.isNodeShape = isNodeShape;
+    NodeShape.schema = {
+        fromRdfType: dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"),
         properties: {
             $identifier: {
                 kind: "Identifier",
@@ -1204,6 +903,14 @@ export var PropertyShape;
                 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" },
+                },
+            },
             comment: {
                 kind: "Shacl",
                 path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
@@ -1225,38 +932,22 @@ export var PropertyShape;
                     itemType: { kind: "Boolean" },
                 },
             },
-            defaultValue: {
-                kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#defaultValue"),
-                type: { kind: "Option", itemType: { kind: "Term" } },
-            },
-            description: {
+            discriminantValue: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#description"),
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#discriminantValue"),
                 type: {
                     kind: "Option",
                     itemType: { kind: "String" },
                 },
             },
-            disjoint: {
-                kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#disjoint"),
-                type: { kind: "Set", itemType: { kind: "Iri" } },
-            },
-            display: {
+            extern: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#display"),
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#extern"),
                 type: {
-                    kind: "DefaultValue",
+                    kind: "Option",
                     itemType: { kind: "Boolean" },
-                    defaultValue: false,
                 },
             },
-            equals: {
-                kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#equals"),
-                type: { kind: "Set", itemType: { kind: "Iri" } },
-            },
             flags: {
                 kind: "Shacl",
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#flags"),
@@ -1265,18 +956,29 @@ export var PropertyShape;
                     itemType: { kind: "String" },
                 },
             },
-            groups: {
+            fromRdfType: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#group"),
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#fromRdfType"),
+                type: { kind: "Option", itemType: { kind: "Iri" } },
+            },
+            hasValues: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#hasValue"),
                 type: {
                     kind: "Set",
-                    itemType: { kind: "Identifier" },
+                    itemType: { kind: "Term", types: ["NamedNode", "Literal"] },
                 },
             },
-            hasValues: {
+            ignoredProperties: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#hasValue"),
-                type: { kind: "Set", itemType: { kind: "Term" } },
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#ignoredProperties"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "List",
+                        itemType: { kind: "Iri" },
+                    },
+                },
             },
             in_: {
                 kind: "Shacl",
@@ -1285,7 +987,10 @@ export var PropertyShape;
                     kind: "Option",
                     itemType: {
                         kind: "List",
-                        itemType: { kind: "Term" },
+                        itemType: {
+                            kind: "Term",
+                            types: ["NamedNode", "Literal"],
+                        },
                     },
                 },
             },
@@ -1316,24 +1021,6 @@ export var PropertyShape;
                     },
                 },
             },
-            lessThan: {
-                kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#lessThan"),
-                type: { kind: "Set", itemType: { kind: "Iri" } },
-            },
-            lessThanOrEquals: {
-                kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#lessThanOrEquals"),
-                type: { kind: "Set", itemType: { kind: "Iri" } },
-            },
-            maxCount: {
-                kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxCount"),
-                type: {
-                    kind: "Option",
-                    itemType: { kind: "BigInt" },
-                },
-            },
             maxExclusive: {
                 kind: "Shacl",
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxExclusive"),
@@ -1366,14 +1053,6 @@ export var PropertyShape;
                     itemType: { kind: "String" },
                 },
             },
-            minCount: {
-                kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minCount"),
-                type: {
-                    kind: "Option",
-                    itemType: { kind: "BigInt" },
-                },
-            },
             minExclusive: {
                 kind: "Shacl",
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minExclusive"),
@@ -1406,14 +1085,6 @@ export var PropertyShape;
                     itemType: { kind: "Boolean" },
                 },
             },
-            name: {
-                kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#name"),
-                type: {
-                    kind: "Option",
-                    itemType: { kind: "String" },
-                },
-            },
             node: {
                 kind: "Shacl",
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#node"),
@@ -1459,18 +1130,6 @@ export var PropertyShape;
                     },
                 },
             },
-            order: {
-                kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#order"),
-                type: { kind: "Option", itemType: { kind: "Float" } },
-            },
-            path: {
-                kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#path"),
-                get type() {
-                    return $PropertyPath.schema;
-                },
-            },
             pattern: {
                 kind: "Shacl",
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#pattern"),
@@ -1479,45 +1138,18 @@ export var PropertyShape;
                     itemType: { kind: "String" },
                 },
             },
-            qualifiedMaxCount: {
-                kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#qualifiedMaxCount"),
-                type: {
-                    kind: "Option",
-                    itemType: { kind: "BigInt" },
-                },
-            },
-            qualifiedMinCount: {
-                kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#qualifiedMinCount"),
-                type: {
-                    kind: "Option",
-                    itemType: { kind: "BigInt" },
-                },
-            },
-            qualifiedValueShape: {
+            properties: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#qualifiedValueShape"),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#property"),
                 type: {
-                    kind: "Option",
+                    kind: "Set",
                     itemType: { kind: "Identifier" },
                 },
             },
-            qualifiedValueShapesDisjoint: {
-                kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#qualifiedValueShapesDisjoint"),
-                type: {
-                    kind: "Option",
-                    itemType: { kind: "Boolean" },
-                },
-            },
-            resolve: {
+            rdfType: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#resolve"),
-                type: {
-                    kind: "Option",
-                    itemType: { kind: "Identifier" },
-                },
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#rdfType"),
+                type: { kind: "Option", itemType: { kind: "Iri" } },
             },
             severity: {
                 kind: "Shacl",
@@ -1542,6 +1174,11 @@ export var PropertyShape;
                     itemType: { kind: "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"),
@@ -1550,7 +1187,10 @@ export var PropertyShape;
             targetNodes: {
                 kind: "Shacl",
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetNode"),
-                type: { kind: "Set", itemType: { kind: "Term" } },
+                type: {
+                    kind: "Set",
+                    itemType: { kind: "Term", types: ["NamedNode", "Literal"] },
+                },
             },
             targetObjectsOf: {
                 kind: "Shacl",
@@ -1562,13 +1202,20 @@ export var PropertyShape;
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetSubjectsOf"),
                 type: { kind: "Set", itemType: { kind: "Iri" } },
             },
-            uniqueLang: {
+            toRdfTypes: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#uniqueLang"),
-                type: {
-                    kind: "Option",
-                    itemType: { kind: "Boolean" },
-                },
+                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" } },
+            },
+            types: {
+                kind: "Shacl",
+                path: $RdfVocabularies.rdf.type,
+                type: { kind: "Set", itemType: { kind: "Iri" } },
             },
             xone: {
                 kind: "Shacl",
@@ -1583,11 +1230,11 @@ export var PropertyShape;
             },
         },
     };
-    PropertyShape._toRdfResource = (parameters) => {
+    NodeShape._toRdfResource = (parameters) => {
         if (!parameters.ignoreRdfType) {
-            parameters.resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"), parameters.graph);
+            parameters.resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"), parameters.graph);
         }
-        parameters.resource.add(PropertyShape.schema.properties.and.path, parameters.object.and.toList().flatMap((value) => [
+        parameters.resource.add(NodeShape.schema.properties.and.path, parameters.object.and.toList().flatMap((value) => [
             value.length > 0
                 ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
                     if (itemIndex === 0) {
@@ -1609,33 +1256,57 @@ export var PropertyShape;
                 }).listResource.identifier
                 : $RdfVocabularies.rdf.nil,
         ]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.classes.path, parameters.object.classes.flatMap((item) => [item]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.comment.path, parameters.object.comment
+        parameters.resource.add(NodeShape.schema.properties.classes.path, parameters.object.classes.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.closed.path, parameters.object.closed
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
+        ]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.comment.path, parameters.object.comment
             .toList()
             .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.datatype.path, parameters.object.datatype.toList(), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.deactivated.path, parameters.object.deactivated
+        parameters.resource.add(NodeShape.schema.properties.datatype.path, parameters.object.datatype.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.deactivated.path, parameters.object.deactivated
             .toList()
             .flatMap((value) => [
             $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
         ]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.defaultValue.path, parameters.object.defaultValue.toList(), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.description.path, parameters.object.description
+        parameters.resource.add(NodeShape.schema.properties.discriminantValue.path, parameters.object.discriminantValue
             .toList()
             .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.disjoint.path, parameters.object.disjoint.flatMap((item) => [item]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.display.path, $strictEquals(parameters.object.display, false).isLeft()
-            ? [
-                $literalFactory.boolean(parameters.object.display, $RdfVocabularies.xsd.boolean),
-            ]
-            : [], parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.equals.path, parameters.object.equals.flatMap((item) => [item]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.flags.path, parameters.object.flags
+        parameters.resource.add(NodeShape.schema.properties.extern.path, parameters.object.extern
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
+        ]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.flags.path, parameters.object.flags
             .toList()
             .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.groups.path, parameters.object.groups.flatMap((item) => [item]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.hasValues.path, parameters.object.hasValues.flatMap((item) => [item]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.in_.path, parameters.object.in_.toList().flatMap((value) => [
+        parameters.resource.add(NodeShape.schema.properties.fromRdfType.path, parameters.object.fromRdfType.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.hasValues.path, parameters.object.hasValues.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.ignoredProperties.path, parameters.object.ignoredProperties.toList().flatMap((value) => [
+            value.length > 0
+                ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+                    if (itemIndex === 0) {
+                        currentSubListResource = listResource;
+                    }
+                    else {
+                        const newSubListResource = parameters.resourceSet.resource((() => dataFactory.blankNode())());
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, parameters.graph);
+                        currentSubListResource = newSubListResource;
+                    }
+                    currentSubListResource.add($RdfVocabularies.rdf.first, [item], parameters.graph);
+                    if (itemIndex + 1 === list.length) {
+                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, parameters.graph);
+                    }
+                    return { currentSubListResource, listResource };
+                }, {
+                    currentSubListResource: null,
+                    listResource: parameters.resourceSet.resource((() => dataFactory.blankNode())()),
+                }).listResource.identifier
+                : $RdfVocabularies.rdf.nil,
+        ]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.in_.path, parameters.object.in_.toList().flatMap((value) => [
             value.length > 0
                 ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
                     if (itemIndex === 0) {
@@ -1657,11 +1328,11 @@ export var PropertyShape;
                 }).listResource.identifier
                 : $RdfVocabularies.rdf.nil,
         ]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.isDefinedBy.path, parameters.object.isDefinedBy.toList(), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.label.path, parameters.object.label
+        parameters.resource.add(NodeShape.schema.properties.isDefinedBy.path, parameters.object.isDefinedBy.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.label.path, parameters.object.label
             .toList()
             .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.languageIn.path, parameters.object.languageIn.toList().flatMap((value) => [
+        parameters.resource.add(NodeShape.schema.properties.languageIn.path, parameters.object.languageIn.toList().flatMap((value) => [
             value.length > 0
                 ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
                     if (itemIndex === 0) {
@@ -1683,47 +1354,32 @@ export var PropertyShape;
                 }).listResource.identifier
                 : $RdfVocabularies.rdf.nil,
         ]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.lessThan.path, parameters.object.lessThan.flatMap((item) => [item]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.lessThanOrEquals.path, parameters.object.lessThanOrEquals.flatMap((item) => [item]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.maxCount.path, parameters.object.maxCount
-            .toList()
-            .flatMap((value) => [
-            $literalFactory.bigint(value, $RdfVocabularies.xsd.integer),
-        ]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.maxExclusive.path, parameters.object.maxExclusive.toList(), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.maxInclusive.path, parameters.object.maxInclusive.toList(), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.maxLength.path, parameters.object.maxLength
+        parameters.resource.add(NodeShape.schema.properties.maxExclusive.path, parameters.object.maxExclusive.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.maxInclusive.path, parameters.object.maxInclusive.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.maxLength.path, parameters.object.maxLength
             .toList()
             .flatMap((value) => [
             $literalFactory.bigint(value, $RdfVocabularies.xsd.integer),
         ]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.message.path, parameters.object.message
+        parameters.resource.add(NodeShape.schema.properties.message.path, parameters.object.message
             .toList()
             .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.minCount.path, parameters.object.minCount
-            .toList()
-            .flatMap((value) => [
-            $literalFactory.bigint(value, $RdfVocabularies.xsd.integer),
-        ]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.minExclusive.path, parameters.object.minExclusive.toList(), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.minInclusive.path, parameters.object.minInclusive.toList(), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.minLength.path, parameters.object.minLength
+        parameters.resource.add(NodeShape.schema.properties.minExclusive.path, parameters.object.minExclusive.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.minInclusive.path, parameters.object.minInclusive.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.minLength.path, parameters.object.minLength
             .toList()
             .flatMap((value) => [
             $literalFactory.bigint(value, $RdfVocabularies.xsd.integer),
         ]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.mutable.path, parameters.object.mutable
+        parameters.resource.add(NodeShape.schema.properties.mutable.path, parameters.object.mutable
             .toList()
             .flatMap((value) => [
             $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
         ]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.name.path, parameters.object.name
-            .toList()
-            .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.node.path, parameters.object.node.toList(), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.nodeKind.path, parameters.object.nodeKind.toList(), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.not.path, parameters.object.not.flatMap((item) => [item]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.or.path, parameters.object.or.toList().flatMap((value) => [
+        parameters.resource.add(NodeShape.schema.properties.node.path, parameters.object.node.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.nodeKind.path, parameters.object.nodeKind.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.not.path, parameters.object.not.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.or.path, parameters.object.or.toList().flatMap((value) => [
             value.length > 0
                 ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
                     if (itemIndex === 0) {
@@ -1745,51 +1401,26 @@ export var PropertyShape;
                 }).listResource.identifier
                 : $RdfVocabularies.rdf.nil,
         ]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.order.path, parameters.object.order
-            .toList()
-            .flatMap((value) => [
-            $literalFactory.number(value, $RdfVocabularies.xsd.double),
-        ]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.path.path, [
-            $PropertyPath.toRdfResource(parameters.object.path, {
-                graph: parameters.graph,
-                resourceSet: parameters.resourceSet,
-            }).identifier,
-        ], parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.pattern.path, parameters.object.pattern
+        parameters.resource.add(NodeShape.schema.properties.pattern.path, parameters.object.pattern
             .toList()
             .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.qualifiedMaxCount.path, parameters.object.qualifiedMaxCount
-            .toList()
-            .flatMap((value) => [
-            $literalFactory.bigint(value, $RdfVocabularies.xsd.integer),
-        ]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.qualifiedMinCount.path, parameters.object.qualifiedMinCount
-            .toList()
-            .flatMap((value) => [
-            $literalFactory.bigint(value, $RdfVocabularies.xsd.integer),
-        ]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.qualifiedValueShape.path, parameters.object.qualifiedValueShape.toList(), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.qualifiedValueShapesDisjoint.path, parameters.object.qualifiedValueShapesDisjoint
-            .toList()
-            .flatMap((value) => [
-            $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
-        ]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.resolve.path, parameters.object.resolve.toList(), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.severity.path, parameters.object.severity.toList(), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.shaclmateName.path, parameters.object.shaclmateName
+        parameters.resource.add(NodeShape.schema.properties.properties.path, parameters.object.properties.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.rdfType.path, parameters.object.rdfType.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.severity.path, parameters.object.severity.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.shaclmateName.path, parameters.object.shaclmateName
             .toList()
             .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.targetClasses.path, parameters.object.targetClasses.flatMap((item) => [item]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.targetNodes.path, parameters.object.targetNodes.flatMap((item) => [item]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.targetObjectsOf.path, parameters.object.targetObjectsOf.flatMap((item) => [item]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.targetSubjectsOf.path, parameters.object.targetSubjectsOf.flatMap((item) => [item]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.uniqueLang.path, parameters.object.uniqueLang
-            .toList()
-            .flatMap((value) => [
-            $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
+        parameters.resource.add(NodeShape.schema.properties.subClassOf.path, parameters.object.subClassOf.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.targetClasses.path, parameters.object.targetClasses.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.targetNodes.path, parameters.object.targetNodes.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.targetObjectsOf.path, parameters.object.targetObjectsOf.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.targetSubjectsOf.path, parameters.object.targetSubjectsOf.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.toRdfTypes.path, parameters.object.toRdfTypes.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.tsImports.path, parameters.object.tsImports.flatMap((item) => [
+            $literalFactory.string(item),
         ]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.xone.path, parameters.object.xone.toList().flatMap((value) => [
+        parameters.resource.add(NodeShape.schema.properties.types.path, parameters.object.types.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.xone.path, parameters.object.xone.toList().flatMap((value) => [
             value.length > 0
                 ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
                     if (itemIndex === 0) {
@@ -1813,104 +1444,81 @@ export var PropertyShape;
         ]), parameters.graph);
         return parameters.resource;
     };
-    PropertyShape.toRdfResource = $wrap_ToRdfResourceFunction(PropertyShape._toRdfResource);
-    function _propertiesToStrings(_propertyShape) {
-        return $compactRecord({
-            $identifier: _propertyShape.$identifier().toString(),
-            label: _propertyShape.label.map((item) => item.toString()).extract(),
-            name: _propertyShape.name.map((item) => item.toString()).extract(),
-            path: $PropertyPath.$toString(_propertyShape.path),
-            shaclmateName: _propertyShape.shaclmateName
-                .map((item) => item.toString())
-                .extract(),
-        });
-    }
-    PropertyShape._propertiesToStrings = _propertiesToStrings;
-    function $toString(_propertyShape) {
-        return `PropertyShape(${JSON.stringify(_propertiesToStrings(_propertyShape))})`;
-    }
-    PropertyShape.$toString = $toString;
-})(PropertyShape || (PropertyShape = {}));
-export var PropertyGroup;
-(function (PropertyGroup) {
-    function create(parameters) {
-        return $sequenceRecord({
-            $identifier: $convertToIdentifierProperty(parameters?.$identifier),
-            comment: $convertToMaybe($identityConversionFunction)(parameters?.comment).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.comment.type, value)),
-            label: $convertToMaybe($identityConversionFunction)(parameters?.label).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.label.type, value)),
-        }).map((properties) => $monkeyPatchObject({ ...properties, $type: "PropertyGroup" }, { $toString }));
-    }
-    PropertyGroup.create = create;
+    NodeShape.toRdfResource = $wrap_ToRdfResourceFunction(NodeShape._toRdfResource);
+    NodeShape.$toString = (_nodeShape) => `NodeShape(${JSON.stringify(NodeShape.toStringRecord(_nodeShape))})`;
+    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.create = (parameters) => $sequenceRecord({
+        $identifier: $convertToIdentifierProperty(parameters?.$identifier),
+        comment: $convertToMaybe($identityConversionFunction)(parameters?.comment).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.comment.type, value)),
+        label: $convertToMaybe($identityConversionFunction)(parameters?.label).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 create(parameters).unsafeCoerce();
+        return Ontology.create(parameters).unsafeCoerce();
     }
-    PropertyGroup.createUnsafe = createUnsafe;
+    Ontology.createUnsafe = createUnsafe;
+    Ontology._fromRdfResource = ($resource, _$options) => (!_$options.ignoreRdfType
+        ? $ensureRdfResourceType($resource, [Ontology.schema.fromRdfType], {
+            graph: _$options.graph,
+        })
+        : Right(true)).chain((_rdfTypeCheck) => $sequenceRecord({
+        $identifier: $identifierFromRdfResourceValues(new Resource.Value({
+            dataFactory: dataFactory,
+            focusResource: $resource,
+            propertyPath: $RdfVocabularies.rdf.subject,
+            term: $resource.identifier,
+        }).toValues(), {
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            preferredLanguages: _$options.preferredLanguages,
+            propertyPath: $RdfVocabularies.rdf.subject,
+            schema: Ontology.schema.properties.$identifier.type,
+        }).chain((values) => values.head()),
+        comment: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: Ontology.schema.properties.comment,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        label: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: Ontology.schema.properties.label,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+    }).chain((properties) => Ontology.create(properties)));
+    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.stringify = NTriplesTerm.stringify;
-    })(Identifier = PropertyGroup.Identifier || (PropertyGroup.Identifier = {}));
-    PropertyGroup._fromRdfResource = ($resource, _$options) => {
-        return (!_$options.ignoreRdfType
-            ? $ensureRdfResourceType($resource, [PropertyGroup.fromRdfType], {
-                graph: _$options.graph,
-            })
-            : Right(true)).chain((_rdfTypeCheck) => $sequenceRecord({
-            $identifier: Right(new Resource.Value({
-                dataFactory: dataFactory,
-                focusResource: $resource,
-                propertyPath: $RdfVocabularies.rdf.subject,
-                term: $resource.identifier,
-            }).toValues())
-                .chain((values) => values.chainMap((value) => value.toIdentifier()))
-                .chain((values) => values.head()),
-            comment: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyGroup.schema.properties.comment,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toString()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.comment.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            label: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyGroup.schema.properties.label,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toString()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.label.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-        }).chain((properties) => create(properties)));
-    };
-    PropertyGroup.fromRdfResource = $wrap_FromRdfResourceFunction(PropertyGroup._fromRdfResource);
-    PropertyGroup.fromRdfResourceValues = (values, options) => values.chain((values) => values.chainMap((value) => value
-        .toResource()
-        .chain((resource) => PropertyGroup.fromRdfResource(resource, options))));
-    PropertyGroup.fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup");
-    function isPropertyGroup(object) {
-        switch (object.$type) {
-            case "PropertyGroup":
-                return true;
-            default:
-                return false;
-        }
+    })(Identifier = Ontology.Identifier || (Ontology.Identifier = {}));
+    function isOntology(object) {
+        return object.$type === "Ontology";
     }
-    PropertyGroup.isPropertyGroup = isPropertyGroup;
-    PropertyGroup.schema = {
+    Ontology.isOntology = isOntology;
+    Ontology.schema = {
+        fromRdfType: dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"),
         properties: {
             $identifier: {
                 kind: "Identifier",
@@ -1934,111 +1542,90 @@ export var PropertyGroup;
             },
         },
     };
-    PropertyGroup._toRdfResource = (parameters) => {
+    Ontology._toRdfResource = (parameters) => {
         if (!parameters.ignoreRdfType) {
-            parameters.resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup"), parameters.graph);
+            parameters.resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"), parameters.graph);
         }
-        parameters.resource.add(PropertyShape.schema.properties.comment.path, parameters.object.comment
+        parameters.resource.add(NodeShape.schema.properties.comment.path, parameters.object.comment
             .toList()
             .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.label.path, parameters.object.label
+        parameters.resource.add(NodeShape.schema.properties.label.path, parameters.object.label
             .toList()
             .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
         return parameters.resource;
     };
-    PropertyGroup.toRdfResource = $wrap_ToRdfResourceFunction(PropertyGroup._toRdfResource);
-    function _propertiesToStrings(_propertyGroup) {
-        return $compactRecord({
-            $identifier: _propertyGroup.$identifier().toString(),
-            label: _propertyGroup.label.map((item) => item.toString()).extract(),
-        });
-    }
-    PropertyGroup._propertiesToStrings = _propertiesToStrings;
-    function $toString(_propertyGroup) {
-        return `PropertyGroup(${JSON.stringify(_propertiesToStrings(_propertyGroup))})`;
-    }
-    PropertyGroup.$toString = $toString;
-})(PropertyGroup || (PropertyGroup = {}));
-export var Ontology;
-(function (Ontology) {
-    function create(parameters) {
-        return $sequenceRecord({
-            $identifier: $convertToIdentifierProperty(parameters?.$identifier),
-            comment: $convertToMaybe($identityConversionFunction)(parameters?.comment).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.comment.type, value)),
-            label: $convertToMaybe($identityConversionFunction)(parameters?.label).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.label.type, value)),
-        }).map((properties) => $monkeyPatchObject({ ...properties, $type: "Ontology" }, { $toString }));
-    }
-    Ontology.create = create;
+    Ontology.toRdfResource = $wrap_ToRdfResourceFunction(Ontology._toRdfResource);
+    Ontology.$toString = (_ontology) => `Ontology(${JSON.stringify(Ontology.toStringRecord(_ontology))})`;
+    Ontology.toStringRecord = (_ontology) => $compactRecord({
+        $identifier: _ontology.$identifier().toString(),
+        label: _ontology.label.map((item) => item.toString()).extract(),
+    });
+})(Ontology || (Ontology = {}));
+export var PropertyGroup;
+(function (PropertyGroup) {
+    PropertyGroup.create = (parameters) => $sequenceRecord({
+        $identifier: $convertToIdentifierProperty(parameters?.$identifier),
+        comment: $convertToMaybe($identityConversionFunction)(parameters?.comment).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.comment.type, value)),
+        label: $convertToMaybe($identityConversionFunction)(parameters?.label).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 create(parameters).unsafeCoerce();
+        return PropertyGroup.create(parameters).unsafeCoerce();
     }
-    Ontology.createUnsafe = createUnsafe;
+    PropertyGroup.createUnsafe = createUnsafe;
+    PropertyGroup._fromRdfResource = ($resource, _$options) => (!_$options.ignoreRdfType
+        ? $ensureRdfResourceType($resource, [PropertyGroup.schema.fromRdfType], {
+            graph: _$options.graph,
+        })
+        : Right(true)).chain((_rdfTypeCheck) => $sequenceRecord({
+        $identifier: $identifierFromRdfResourceValues(new Resource.Value({
+            dataFactory: dataFactory,
+            focusResource: $resource,
+            propertyPath: $RdfVocabularies.rdf.subject,
+            term: $resource.identifier,
+        }).toValues(), {
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            preferredLanguages: _$options.preferredLanguages,
+            propertyPath: $RdfVocabularies.rdf.subject,
+            schema: PropertyGroup.schema.properties.$identifier.type,
+        }).chain((values) => values.head()),
+        comment: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyGroup.schema.properties.comment,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        label: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyGroup.schema.properties.label,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+    }).chain((properties) => PropertyGroup.create(properties)));
+    PropertyGroup.fromRdfResource = $wrap_FromRdfResourceFunction(PropertyGroup._fromRdfResource);
+    PropertyGroup.fromRdfResourceValues = (values, options) => values.chainMap((value) => value
+        .toResource()
+        .chain((resource) => PropertyGroup.fromRdfResource(resource, options)));
     let Identifier;
     (function (Identifier) {
         Identifier.parse = $parseIdentifier;
         Identifier.stringify = NTriplesTerm.stringify;
-    })(Identifier = Ontology.Identifier || (Ontology.Identifier = {}));
-    Ontology._fromRdfResource = ($resource, _$options) => {
-        return (!_$options.ignoreRdfType
-            ? $ensureRdfResourceType($resource, [Ontology.fromRdfType], {
-                graph: _$options.graph,
-            })
-            : Right(true)).chain((_rdfTypeCheck) => $sequenceRecord({
-            $identifier: Right(new Resource.Value({
-                dataFactory: dataFactory,
-                focusResource: $resource,
-                propertyPath: $RdfVocabularies.rdf.subject,
-                term: $resource.identifier,
-            }).toValues())
-                .chain((values) => values.chainMap((value) => value.toIdentifier()))
-                .chain((values) => values.head()),
-            comment: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: Ontology.schema.properties.comment,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toString()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.comment.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            label: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: Ontology.schema.properties.label,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toString()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.label.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-        }).chain((properties) => create(properties)));
-    };
-    Ontology.fromRdfResource = $wrap_FromRdfResourceFunction(Ontology._fromRdfResource);
-    Ontology.fromRdfResourceValues = (values, options) => values.chain((values) => values.chainMap((value) => value
-        .toResource()
-        .chain((resource) => Ontology.fromRdfResource(resource, options))));
-    Ontology.fromRdfType = dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology");
-    function isOntology(object) {
-        switch (object.$type) {
-            case "Ontology":
-                return true;
-            default:
-                return false;
-        }
+    })(Identifier = PropertyGroup.Identifier || (PropertyGroup.Identifier = {}));
+    function isPropertyGroup(object) {
+        return object.$type === "PropertyGroup";
     }
-    Ontology.isOntology = isOntology;
-    Ontology.schema = {
+    PropertyGroup.isPropertyGroup = isPropertyGroup;
+    PropertyGroup.schema = {
+        fromRdfType: dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup"),
         properties: {
             $identifier: {
                 kind: "Identifier",
@@ -2062,797 +1649,580 @@ export var Ontology;
             },
         },
     };
-    Ontology._toRdfResource = (parameters) => {
+    PropertyGroup._toRdfResource = (parameters) => {
         if (!parameters.ignoreRdfType) {
-            parameters.resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/2002/07/owl#Ontology"), parameters.graph);
+            parameters.resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyGroup"), parameters.graph);
         }
-        parameters.resource.add(PropertyShape.schema.properties.comment.path, parameters.object.comment
+        parameters.resource.add(NodeShape.schema.properties.comment.path, parameters.object.comment
             .toList()
             .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.label.path, parameters.object.label
+        parameters.resource.add(NodeShape.schema.properties.label.path, parameters.object.label
             .toList()
             .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
         return parameters.resource;
     };
-    Ontology.toRdfResource = $wrap_ToRdfResourceFunction(Ontology._toRdfResource);
-    function _propertiesToStrings(_ontology) {
-        return $compactRecord({
-            $identifier: _ontology.$identifier().toString(),
-            label: _ontology.label.map((item) => item.toString()).extract(),
-        });
-    }
-    Ontology._propertiesToStrings = _propertiesToStrings;
-    function $toString(_ontology) {
-        return `Ontology(${JSON.stringify(_propertiesToStrings(_ontology))})`;
-    }
-    Ontology.$toString = $toString;
-})(Ontology || (Ontology = {}));
-export var NodeShape;
-(function (NodeShape) {
-    function create(parameters) {
-        return $sequenceRecord({
-            $identifier: $convertToIdentifierProperty(parameters?.$identifier),
-            and: $convertToMaybe($convertToList($convertToIdentifier, true))(parameters?.and).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(PropertyShape.schema.properties.and.type, value)),
-            classes: $convertToScalarSet(($convertToIri), true)(parameters?.classes).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.classes.type, value)),
-            closed: $convertToMaybe($identityConversionFunction)(parameters?.closed).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.closed.type, value)),
-            comment: $convertToMaybe($identityConversionFunction)(parameters?.comment).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.comment.type, value)),
-            datatype: $convertToMaybe(($convertToIri))(parameters?.datatype).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.datatype.type, value)),
-            deactivated: $convertToMaybe($identityConversionFunction)(parameters?.deactivated).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.deactivated.type, value)),
-            discriminantValue: $convertToMaybe($identityConversionFunction)(parameters?.discriminantValue).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.discriminantValue.type, value)),
-            extern: $convertToMaybe($identityConversionFunction)(parameters?.extern).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.extern.type, value)),
-            flags: $convertToMaybe($identityConversionFunction)(parameters?.flags).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.flags.type, value)),
-            fromRdfType: $convertToMaybe(($convertToIri))(parameters?.fromRdfType).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.fromRdfType.type, value)),
-            hasValues: $convertToScalarSet($identityConversionFunction, true)(parameters?.hasValues).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.hasValues.type, value)),
-            ignoredProperties: $convertToMaybe($convertToList(($convertToIri), true))(parameters?.ignoredProperties).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(NodeShape.schema.properties.ignoredProperties.type, value)),
-            in_: $convertToMaybe($convertToList($identityConversionFunction, true))(parameters?.in_).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(PropertyShape.schema.properties.in_.type, value)),
-            isDefinedBy: $convertToMaybe($convertToIdentifier)(parameters?.isDefinedBy).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.isDefinedBy.type, value)),
-            label: $convertToMaybe($identityConversionFunction)(parameters?.label).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.label.type, value)),
-            languageIn: $convertToMaybe($convertToList($identityConversionFunction, true))(parameters?.languageIn).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(PropertyShape.schema.properties.languageIn.type, value)),
-            maxExclusive: $convertToMaybe($convertToLiteral)(parameters?.maxExclusive).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.maxExclusive.type, value)),
-            maxInclusive: $convertToMaybe($convertToLiteral)(parameters?.maxInclusive).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.maxInclusive.type, value)),
-            maxLength: $convertToMaybe($identityConversionFunction)(parameters?.maxLength).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.maxLength.type, value)),
-            message: $convertToMaybe($identityConversionFunction)(parameters?.message).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.message.type, value)),
-            minExclusive: $convertToMaybe($convertToLiteral)(parameters?.minExclusive).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.minExclusive.type, value)),
-            minInclusive: $convertToMaybe($convertToLiteral)(parameters?.minInclusive).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.minInclusive.type, value)),
-            minLength: $convertToMaybe($identityConversionFunction)(parameters?.minLength).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.minLength.type, value)),
-            mutable: $convertToMaybe($identityConversionFunction)(parameters?.mutable).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.mutable.type, value)),
-            node: $convertToMaybe($convertToIdentifier)(parameters?.node).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.node.type, value)),
-            nodeKind: $convertToMaybe(($convertToIri))(parameters?.nodeKind).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.nodeKind.type, value)),
-            not: $convertToScalarSet($convertToIdentifier, true)(parameters?.not).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.not.type, value)),
-            or: $convertToMaybe($convertToList($convertToIdentifier, true))(parameters?.or).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(PropertyShape.schema.properties.or.type, value)),
-            pattern: $convertToMaybe($identityConversionFunction)(parameters?.pattern).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.pattern.type, value)),
-            properties: $convertToScalarSet($convertToIdentifier, true)(parameters?.properties).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.properties.type, value)),
-            rdfType: $convertToMaybe(($convertToIri))(parameters?.rdfType).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.rdfType.type, value)),
-            severity: $convertToMaybe(($convertToIri))(parameters?.severity).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.severity.type, value)),
-            shaclmateName: $convertToMaybe($identityConversionFunction)(parameters?.shaclmateName).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.shaclmateName.type, value)),
-            subClassOf: $convertToScalarSet(($convertToIri), true)(parameters?.subClassOf).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.subClassOf.type, value)),
-            targetClasses: $convertToScalarSet(($convertToIri), true)(parameters?.targetClasses).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.targetClasses.type, value)),
-            targetNodes: $convertToScalarSet($identityConversionFunction, true)(parameters?.targetNodes).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.targetNodes.type, value)),
-            targetObjectsOf: $convertToScalarSet(($convertToIri), true)(parameters?.targetObjectsOf).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.targetObjectsOf.type, value)),
-            targetSubjectsOf: $convertToScalarSet(($convertToIri), true)(parameters?.targetSubjectsOf).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.targetSubjectsOf.type, value)),
-            toRdfTypes: $convertToScalarSet(($convertToIri), true)(parameters?.toRdfTypes).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.toRdfTypes.type, value)),
-            tsImports: $convertToScalarSet($identityConversionFunction, true)(parameters?.tsImports).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.tsImports.type, value)),
-            types: $convertToScalarSet(($convertToIri), true)(parameters?.types).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.types.type, value)),
-            xone: $convertToMaybe($convertToList($convertToIdentifier, true))(parameters?.xone).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(PropertyShape.schema.properties.xone.type, value)),
-        }).map((properties) => $monkeyPatchObject({ ...properties, $type: "NodeShape" }, { $toString }));
-    }
-    NodeShape.create = create;
+    PropertyGroup.toRdfResource = $wrap_ToRdfResourceFunction(PropertyGroup._toRdfResource);
+    PropertyGroup.$toString = (_propertyGroup) => `PropertyGroup(${JSON.stringify(PropertyGroup.toStringRecord(_propertyGroup))})`;
+    PropertyGroup.toStringRecord = (_propertyGroup) => $compactRecord({
+        $identifier: _propertyGroup.$identifier().toString(),
+        label: _propertyGroup.label.map((item) => item.toString()).extract(),
+    });
+})(PropertyGroup || (PropertyGroup = {}));
+export var PropertyShape;
+(function (PropertyShape) {
+    PropertyShape.create = (parameters) => $sequenceRecord({
+        $identifier: $convertToIdentifierProperty(parameters.$identifier),
+        and: $convertToMaybe($convertToList($convertToIdentifier, true))(parameters.and).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(NodeShape.schema.properties.and.type, value)),
+        classes: $convertToScalarSet(($convertToIri), true)(parameters.classes).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.classes.type, value)),
+        comment: $convertToMaybe($identityConversionFunction)(parameters.comment).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.comment.type, value)),
+        datatype: $convertToMaybe(($convertToIri))(parameters.datatype).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.datatype.type, value)),
+        deactivated: $convertToMaybe($identityConversionFunction)(parameters.deactivated).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.deactivated.type, value)),
+        defaultValue: $convertToMaybe($identityConversionFunction)(parameters.defaultValue).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.defaultValue.type, value)),
+        description: $convertToMaybe($identityConversionFunction)(parameters.description).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.description.type, value)),
+        disjoint: $convertToScalarSet(($convertToIri), true)(parameters.disjoint).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.disjoint.type, value)),
+        display: $convertWithDefaultValue($identityConversionFunction, false)(parameters.display),
+        equals: $convertToScalarSet(($convertToIri), true)(parameters.equals).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.equals.type, value)),
+        flags: $convertToMaybe($identityConversionFunction)(parameters.flags).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.flags.type, value)),
+        groups: $convertToScalarSet($convertToIdentifier, true)(parameters.groups).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.groups.type, value)),
+        hasValues: $convertToScalarSet($identityConversionFunction, true)(parameters.hasValues).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.hasValues.type, value)),
+        ignore: $convertWithDefaultValue($identityConversionFunction, false)(parameters.ignore),
+        in_: $convertToMaybe($convertToList($identityConversionFunction, true))(parameters.in_).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(NodeShape.schema.properties.in_.type, value)),
+        isDefinedBy: $convertToMaybe($convertToIdentifier)(parameters.isDefinedBy).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.isDefinedBy.type, value)),
+        label: $convertToMaybe($identityConversionFunction)(parameters.label).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.label.type, value)),
+        languageIn: $convertToMaybe($convertToList($identityConversionFunction, true))(parameters.languageIn).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(NodeShape.schema.properties.languageIn.type, value)),
+        lessThan: $convertToScalarSet(($convertToIri), true)(parameters.lessThan).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.lessThan.type, value)),
+        lessThanOrEquals: $convertToScalarSet(($convertToIri), true)(parameters.lessThanOrEquals).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.lessThanOrEquals.type, value)),
+        maxCount: $convertToMaybe($identityConversionFunction)(parameters.maxCount).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.maxCount.type, value)),
+        maxExclusive: $convertToMaybe($convertToLiteral)(parameters.maxExclusive).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.maxExclusive.type, value)),
+        maxInclusive: $convertToMaybe($convertToLiteral)(parameters.maxInclusive).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.maxInclusive.type, value)),
+        maxLength: $convertToMaybe($identityConversionFunction)(parameters.maxLength).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.maxLength.type, value)),
+        message: $convertToMaybe($identityConversionFunction)(parameters.message).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.message.type, value)),
+        minCount: $convertToMaybe($identityConversionFunction)(parameters.minCount).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.minCount.type, value)),
+        minExclusive: $convertToMaybe($convertToLiteral)(parameters.minExclusive).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.minExclusive.type, value)),
+        minInclusive: $convertToMaybe($convertToLiteral)(parameters.minInclusive).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.minInclusive.type, value)),
+        minLength: $convertToMaybe($identityConversionFunction)(parameters.minLength).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.minLength.type, value)),
+        mutable: $convertToMaybe($identityConversionFunction)(parameters.mutable).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.mutable.type, value)),
+        name: $convertToMaybe($identityConversionFunction)(parameters.name).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.name.type, value)),
+        node: $convertToMaybe($convertToIdentifier)(parameters.node).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.node.type, value)),
+        nodeKind: $convertToMaybe(($convertToIri))(parameters.nodeKind).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.nodeKind.type, value)),
+        not: $convertToScalarSet($convertToIdentifier, true)(parameters.not).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.not.type, value)),
+        or: $convertToMaybe($convertToList($convertToIdentifier, true))(parameters.or).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(NodeShape.schema.properties.or.type, value)),
+        order: $convertToMaybe($identityConversionFunction)(parameters.order).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.order.type, value)),
+        path: Either.of(parameters.path),
+        pattern: $convertToMaybe($identityConversionFunction)(parameters.pattern).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.pattern.type, value)),
+        qualifiedMaxCount: $convertToMaybe($identityConversionFunction)(parameters.qualifiedMaxCount).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.qualifiedMaxCount.type, value)),
+        qualifiedMinCount: $convertToMaybe($identityConversionFunction)(parameters.qualifiedMinCount).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.qualifiedMinCount.type, value)),
+        qualifiedValueShape: $convertToMaybe($convertToIdentifier)(parameters.qualifiedValueShape).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.qualifiedValueShape.type, value)),
+        qualifiedValueShapesDisjoint: $convertToMaybe($identityConversionFunction)(parameters.qualifiedValueShapesDisjoint).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.qualifiedValueShapesDisjoint.type, value)),
+        resolve: $convertToMaybe($convertToIdentifier)(parameters.resolve).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.resolve.type, value)),
+        severity: $convertToMaybe(($convertToIri))(parameters.severity).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.severity.type, value)),
+        shaclmateName: $convertToMaybe($identityConversionFunction)(parameters.shaclmateName).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.shaclmateName.type, value)),
+        targetClasses: $convertToScalarSet(($convertToIri), true)(parameters.targetClasses).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.targetClasses.type, value)),
+        targetNodes: $convertToScalarSet($identityConversionFunction, true)(parameters.targetNodes).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.targetNodes.type, value)),
+        targetObjectsOf: $convertToScalarSet(($convertToIri), true)(parameters.targetObjectsOf).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.targetObjectsOf.type, value)),
+        targetSubjectsOf: $convertToScalarSet(($convertToIri), true)(parameters.targetSubjectsOf).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.targetSubjectsOf.type, value)),
+        uniqueLang: $convertToMaybe($identityConversionFunction)(parameters.uniqueLang).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.uniqueLang.type, value)),
+        xone: $convertToMaybe($convertToList($convertToIdentifier, true))(parameters.xone).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(NodeShape.schema.properties.xone.type, value)),
+    })
+        .map((properties) => ({ ...properties, $type: "PropertyShape" }))
+        .map((object) => $monkeyPatchObject(object, { $toString: PropertyShape.$toString }));
     function createUnsafe(parameters) {
-        return create(parameters).unsafeCoerce();
+        return PropertyShape.create(parameters).unsafeCoerce();
     }
-    NodeShape.createUnsafe = createUnsafe;
+    PropertyShape.createUnsafe = createUnsafe;
+    PropertyShape._fromRdfResource = ($resource, _$options) => (!_$options.ignoreRdfType
+        ? $ensureRdfResourceType($resource, [PropertyShape.schema.fromRdfType], {
+            graph: _$options.graph,
+        })
+        : Right(true)).chain((_rdfTypeCheck) => $sequenceRecord({
+        $identifier: $identifierFromRdfResourceValues(new Resource.Value({
+            dataFactory: dataFactory,
+            focusResource: $resource,
+            propertyPath: $RdfVocabularies.rdf.subject,
+            term: $resource.identifier,
+        }).toValues(), {
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            preferredLanguages: _$options.preferredLanguages,
+            propertyPath: $RdfVocabularies.rdf.subject,
+            schema: PropertyShape.schema.properties.$identifier.type,
+        }).chain((values) => values.head()),
+        and: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.and,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues($identifierFromRdfResourceValues)),
+        }),
+        classes: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.classes,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        comment: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.comment,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        datatype: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.datatype,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        deactivated: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.deactivated,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($booleanFromRdfResourceValues)),
+        }),
+        defaultValue: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.defaultValue,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($termFromRdfResourceValues)),
+        }),
+        description: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.description,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        disjoint: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.disjoint,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        display: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.display,
+            typeFromRdfResourceValues: $defaultValueFromRdfResourceValues(($booleanFromRdfResourceValues)),
+        }),
+        equals: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.equals,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        flags: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.flags,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        groups: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.groups,
+            typeFromRdfResourceValues: $setFromRdfResourceValues($identifierFromRdfResourceValues),
+        }),
+        hasValues: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.hasValues,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($termFromRdfResourceValues)),
+        }),
+        ignore: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.ignore,
+            typeFromRdfResourceValues: $defaultValueFromRdfResourceValues(($booleanFromRdfResourceValues)),
+        }),
+        in_: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.in_,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues(($termFromRdfResourceValues))),
+        }),
+        isDefinedBy: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.isDefinedBy,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($identifierFromRdfResourceValues),
+        }),
+        label: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.label,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        languageIn: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.languageIn,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues(($stringFromRdfResourceValues))),
+        }),
+        lessThan: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.lessThan,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        lessThanOrEquals: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.lessThanOrEquals,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        maxCount: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.maxCount,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($bigIntFromRdfResourceValues)),
+        }),
+        maxExclusive: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.maxExclusive,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($literalFromRdfResourceValues),
+        }),
+        maxInclusive: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.maxInclusive,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($literalFromRdfResourceValues),
+        }),
+        maxLength: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.maxLength,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($bigIntFromRdfResourceValues)),
+        }),
+        message: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.message,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        minCount: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.minCount,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($bigIntFromRdfResourceValues)),
+        }),
+        minExclusive: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.minExclusive,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($literalFromRdfResourceValues),
+        }),
+        minInclusive: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.minInclusive,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($literalFromRdfResourceValues),
+        }),
+        minLength: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.minLength,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($bigIntFromRdfResourceValues)),
+        }),
+        mutable: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.mutable,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($booleanFromRdfResourceValues)),
+        }),
+        name: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.name,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        node: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.node,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($identifierFromRdfResourceValues),
+        }),
+        nodeKind: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.nodeKind,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        not: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.not,
+            typeFromRdfResourceValues: $setFromRdfResourceValues($identifierFromRdfResourceValues),
+        }),
+        or: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.or,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues($identifierFromRdfResourceValues)),
+        }),
+        order: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.order,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($floatFromRdfResourceValues)),
+        }),
+        path: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.path,
+            typeFromRdfResourceValues: $PropertyPath.fromRdfResourceValues,
+        }),
+        pattern: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.pattern,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        qualifiedMaxCount: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.qualifiedMaxCount,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($bigIntFromRdfResourceValues)),
+        }),
+        qualifiedMinCount: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.qualifiedMinCount,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($bigIntFromRdfResourceValues)),
+        }),
+        qualifiedValueShape: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.qualifiedValueShape,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($identifierFromRdfResourceValues),
+        }),
+        qualifiedValueShapesDisjoint: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.qualifiedValueShapesDisjoint,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($booleanFromRdfResourceValues)),
+        }),
+        resolve: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.resolve,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($identifierFromRdfResourceValues),
+        }),
+        severity: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.severity,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        shaclmateName: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.shaclmateName,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        targetClasses: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.targetClasses,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        targetNodes: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.targetNodes,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($termFromRdfResourceValues)),
+        }),
+        targetObjectsOf: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.targetObjectsOf,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        targetSubjectsOf: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.targetSubjectsOf,
+            typeFromRdfResourceValues: $setFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        uniqueLang: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.uniqueLang,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($booleanFromRdfResourceValues)),
+        }),
+        xone: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.xone,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues($listFromRdfResourceValues($identifierFromRdfResourceValues)),
+        }),
+    }).chain((properties) => PropertyShape.create(properties)));
+    PropertyShape.fromRdfResource = $wrap_FromRdfResourceFunction(PropertyShape._fromRdfResource);
+    PropertyShape.fromRdfResourceValues = (values, options) => values.chainMap((value) => value
+        .toResource()
+        .chain((resource) => PropertyShape.fromRdfResource(resource, options)));
     let Identifier;
     (function (Identifier) {
         Identifier.parse = $parseIdentifier;
         Identifier.stringify = NTriplesTerm.stringify;
-    })(Identifier = NodeShape.Identifier || (NodeShape.Identifier = {}));
-    NodeShape._fromRdfResource = ($resource, _$options) => {
-        return (!_$options.ignoreRdfType
-            ? $ensureRdfResourceType($resource, [NodeShape.fromRdfType], {
-                graph: _$options.graph,
-            })
-            : Right(true)).chain((_rdfTypeCheck) => $sequenceRecord({
-            $identifier: Right(new Resource.Value({
-                dataFactory: dataFactory,
-                focusResource: $resource,
-                propertyPath: $RdfVocabularies.rdf.subject,
-                term: $resource.identifier,
-            }).toValues())
-                .chain((values) => values.chainMap((value) => value.toIdentifier()))
-                .chain((values) => values.head()),
-            and: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.and,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toList({ graph: _$options.graph })))
-                    .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.and.path,
-                    values: valueList.toArray(),
-                })).chain((values) => values.chainMap((value) => value.toIdentifier()))))
-                    .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.and.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            classes: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.classes,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIri()))
-                    .map((values) => values.toArray())
-                    .map((valuesArray) => Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.classes.path,
-                    value: valuesArray,
-                })),
-            }),
-            closed: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.closed,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toBoolean()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: NodeShape.schema.properties.closed.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            comment: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.comment,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toString()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.comment.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            datatype: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.datatype,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIri()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.datatype.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            deactivated: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.deactivated,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toBoolean()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.deactivated.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            discriminantValue: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.discriminantValue,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toString()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: NodeShape.schema.properties.discriminantValue.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            extern: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.extern,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toBoolean()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: NodeShape.schema.properties.extern.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            flags: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.flags,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toString()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.flags.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            fromRdfType: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.fromRdfType,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIri()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: NodeShape.schema.properties.fromRdfType.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            hasValues: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.hasValues,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toTerm().chain((term) => {
-                    switch (term.termType) {
-                        case "NamedNode":
-                        case "Literal":
-                            return Either.of(term);
-                        default:
-                            return Left(new Resource.MistypedTermValueError({
-                                actualValue: term,
-                                expectedValueType: "(NamedNode | Literal)",
-                                focusResource: $resource,
-                                propertyPath: PropertyShape.schema.properties.hasValues.path,
-                            }));
-                    }
-                })))
-                    .map((values) => values.toArray())
-                    .map((valuesArray) => Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.hasValues.path,
-                    value: valuesArray,
-                })),
-            }),
-            ignoredProperties: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.ignoredProperties,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toList({ graph: _$options.graph })))
-                    .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
-                    focusResource: $resource,
-                    propertyPath: NodeShape.schema.properties.ignoredProperties.path,
-                    values: valueList.toArray(),
-                })).chain((values) => values.chainMap((value) => value.toIri()))))
-                    .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: NodeShape.schema.properties.ignoredProperties.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            in_: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.in_,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toList({ graph: _$options.graph })))
-                    .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.in_.path,
-                    values: valueList.toArray(),
-                })).chain((values) => values.chainMap((value) => value.toTerm().chain((term) => {
-                    switch (term.termType) {
-                        case "NamedNode":
-                        case "Literal":
-                            return Either.of(term);
-                        default:
-                            return Left(new Resource.MistypedTermValueError({
-                                actualValue: term,
-                                expectedValueType: "(NamedNode | Literal)",
-                                focusResource: $resource,
-                                propertyPath: PropertyShape.schema.properties.in_.path,
-                            }));
-                    }
-                })))))
-                    .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.in_.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            isDefinedBy: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.isDefinedBy,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIdentifier()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.isDefinedBy.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            label: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.label,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toString()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.label.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            languageIn: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.languageIn,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toList({ graph: _$options.graph })))
-                    .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.languageIn.path,
-                    values: valueList.toArray(),
-                }))
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toString()))))
-                    .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.languageIn.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            maxExclusive: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.maxExclusive,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toLiteral()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.maxExclusive.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            maxInclusive: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.maxInclusive,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toLiteral()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.maxInclusive.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            maxLength: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.maxLength,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toBigInt()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.maxLength.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            message: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.message,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toString()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.message.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            minExclusive: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.minExclusive,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toLiteral()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.minExclusive.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            minInclusive: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.minInclusive,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toLiteral()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.minInclusive.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            minLength: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.minLength,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toBigInt()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.minLength.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            mutable: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.mutable,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toBoolean()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.mutable.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            node: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.node,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIdentifier()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.node.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            nodeKind: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.nodeKind,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIri([
-                    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"),
-                ])))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.nodeKind.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            not: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.not,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIdentifier()))
-                    .map((values) => values.toArray())
-                    .map((valuesArray) => Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.not.path,
-                    value: valuesArray,
-                })),
-            }),
-            or: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.or,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toList({ graph: _$options.graph })))
-                    .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.or.path,
-                    values: valueList.toArray(),
-                })).chain((values) => values.chainMap((value) => value.toIdentifier()))))
-                    .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.or.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            pattern: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.pattern,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toString()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.pattern.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            properties: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.properties,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIdentifier()))
-                    .map((values) => values.toArray())
-                    .map((valuesArray) => Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: NodeShape.schema.properties.properties.path,
-                    value: valuesArray,
-                })),
-            }),
-            rdfType: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.rdfType,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIri()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: NodeShape.schema.properties.rdfType.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            severity: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.severity,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIri([
-                    dataFactory.namedNode("http://www.w3.org/ns/shacl#Info"),
-                    dataFactory.namedNode("http://www.w3.org/ns/shacl#Warning"),
-                    dataFactory.namedNode("http://www.w3.org/ns/shacl#Violation"),
-                ])))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.severity.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            shaclmateName: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.shaclmateName,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toString()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.shaclmateName.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-            subClassOf: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.subClassOf,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIri()))
-                    .map((values) => values.toArray())
-                    .map((valuesArray) => Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: NodeShape.schema.properties.subClassOf.path,
-                    value: valuesArray,
-                })),
-            }),
-            targetClasses: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.targetClasses,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIri()))
-                    .map((values) => values.toArray())
-                    .map((valuesArray) => Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.targetClasses.path,
-                    value: valuesArray,
-                })),
-            }),
-            targetNodes: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.targetNodes,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toTerm().chain((term) => {
-                    switch (term.termType) {
-                        case "NamedNode":
-                        case "Literal":
-                            return Either.of(term);
-                        default:
-                            return Left(new Resource.MistypedTermValueError({
-                                actualValue: term,
-                                expectedValueType: "(NamedNode | Literal)",
-                                focusResource: $resource,
-                                propertyPath: PropertyShape.schema.properties.targetNodes.path,
-                            }));
-                    }
-                })))
-                    .map((values) => values.toArray())
-                    .map((valuesArray) => Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.targetNodes.path,
-                    value: valuesArray,
-                })),
-            }),
-            targetObjectsOf: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.targetObjectsOf,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIri()))
-                    .map((values) => values.toArray())
-                    .map((valuesArray) => Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.targetObjectsOf.path,
-                    value: valuesArray,
-                })),
-            }),
-            targetSubjectsOf: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.targetSubjectsOf,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIri()))
-                    .map((values) => values.toArray())
-                    .map((valuesArray) => Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.targetSubjectsOf.path,
-                    value: valuesArray,
-                })),
-            }),
-            toRdfTypes: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.toRdfTypes,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIri()))
-                    .map((values) => values.toArray())
-                    .map((valuesArray) => Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: NodeShape.schema.properties.toRdfTypes.path,
-                    value: valuesArray,
-                })),
-            }),
-            tsImports: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.tsImports,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                    .chain((values) => values.chainMap((value) => value.toString()))
-                    .map((values) => values.toArray())
-                    .map((valuesArray) => Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: NodeShape.schema.properties.tsImports.path,
-                    value: valuesArray,
-                })),
-            }),
-            types: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.types,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toIri()))
-                    .map((values) => values.toArray())
-                    .map((valuesArray) => Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: NodeShape.schema.properties.types.path,
-                    value: valuesArray,
-                })),
-            }),
-            xone: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.xone,
-                typeFromRdf: (resourceValues) => resourceValues
-                    .chain((values) => values.chainMap((value) => value.toList({ graph: _$options.graph })))
-                    .chain((valueLists) => valueLists.chainMap((valueList) => Right(Resource.Values.fromArray({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.xone.path,
-                    values: valueList.toArray(),
-                })).chain((values) => values.chainMap((value) => value.toIdentifier()))))
-                    .map((valueLists) => valueLists.map((valueList) => valueList.toArray()))
-                    .map((values) => values.length > 0
-                    ? values.map((value) => Maybe.of(value))
-                    : Resource.Values.fromValue({
-                        focusResource: $resource,
-                        propertyPath: PropertyShape.schema.properties.xone.path,
-                        value: Maybe.empty(),
-                    })),
-            }),
-        }).chain((properties) => create(properties)));
-    };
-    NodeShape.fromRdfResource = $wrap_FromRdfResourceFunction(NodeShape._fromRdfResource);
-    NodeShape.fromRdfResourceValues = (values, options) => values.chain((values) => values.chainMap((value) => value
-        .toResource()
-        .chain((resource) => NodeShape.fromRdfResource(resource, options))));
-    NodeShape.fromRdfType = dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape");
-    function isNodeShape(object) {
-        switch (object.$type) {
-            case "NodeShape":
-                return true;
-            default:
-                return false;
-        }
+    })(Identifier = PropertyShape.Identifier || (PropertyShape.Identifier = {}));
+    function isPropertyShape(object) {
+        return object.$type === "PropertyShape";
     }
-    NodeShape.isNodeShape = isNodeShape;
-    NodeShape.schema = {
+    PropertyShape.isPropertyShape = isPropertyShape;
+    PropertyShape.schema = {
+        fromRdfType: dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"),
         properties: {
             $identifier: {
                 kind: "Identifier",
@@ -2874,14 +2244,6 @@ export var NodeShape;
                 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" },
-                },
-            },
             comment: {
                 kind: "Shacl",
                 path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
@@ -2903,22 +2265,41 @@ export var NodeShape;
                     itemType: { kind: "Boolean" },
                 },
             },
-            discriminantValue: {
+            defaultValue: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#discriminantValue"),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#defaultValue"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "String" },
+                    itemType: { kind: "Term", types: ["NamedNode", "Literal"] },
                 },
             },
-            extern: {
+            description: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#extern"),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#description"),
                 type: {
                     kind: "Option",
+                    itemType: { kind: "String" },
+                },
+            },
+            disjoint: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#disjoint"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            display: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#display"),
+                type: {
+                    kind: "DefaultValue",
                     itemType: { kind: "Boolean" },
+                    defaultValue: dataFactory.literal("false", $RdfVocabularies.xsd.boolean),
                 },
             },
+            equals: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#equals"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
             flags: {
                 kind: "Shacl",
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#flags"),
@@ -2927,25 +2308,29 @@ export var NodeShape;
                     itemType: { kind: "String" },
                 },
             },
-            fromRdfType: {
+            groups: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#fromRdfType"),
-                type: { kind: "Option", itemType: { kind: "Iri" } },
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#group"),
+                type: {
+                    kind: "Set",
+                    itemType: { kind: "Identifier" },
+                },
             },
             hasValues: {
                 kind: "Shacl",
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#hasValue"),
-                type: { kind: "Set", itemType: { kind: "Term" } },
+                type: {
+                    kind: "Set",
+                    itemType: { kind: "Term", types: ["NamedNode", "Literal"] },
+                },
             },
-            ignoredProperties: {
+            ignore: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#ignoredProperties"),
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#ignore"),
                 type: {
-                    kind: "Option",
-                    itemType: {
-                        kind: "List",
-                        itemType: { kind: "Iri" },
-                    },
+                    kind: "DefaultValue",
+                    itemType: { kind: "Boolean" },
+                    defaultValue: dataFactory.literal("false", $RdfVocabularies.xsd.boolean),
                 },
             },
             in_: {
@@ -2955,7 +2340,10 @@ export var NodeShape;
                     kind: "Option",
                     itemType: {
                         kind: "List",
-                        itemType: { kind: "Term" },
+                        itemType: {
+                            kind: "Term",
+                            types: ["NamedNode", "Literal"],
+                        },
                     },
                 },
             },
@@ -2986,6 +2374,24 @@ export var NodeShape;
                     },
                 },
             },
+            lessThan: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#lessThan"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            lessThanOrEquals: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#lessThanOrEquals"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            maxCount: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxCount"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "BigInt" },
+                },
+            },
             maxExclusive: {
                 kind: "Shacl",
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#maxExclusive"),
@@ -3018,6 +2424,14 @@ export var NodeShape;
                     itemType: { kind: "String" },
                 },
             },
+            minCount: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minCount"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "BigInt" },
+                },
+            },
             minExclusive: {
                 kind: "Shacl",
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minExclusive"),
@@ -3050,6 +2464,14 @@ export var NodeShape;
                     itemType: { kind: "Boolean" },
                 },
             },
+            name: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#name"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
+            },
             node: {
                 kind: "Shacl",
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#node"),
@@ -3095,6 +2517,18 @@ export var NodeShape;
                     },
                 },
             },
+            order: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#order"),
+                type: { kind: "Option", itemType: { kind: "Float" } },
+            },
+            path: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#path"),
+                get type() {
+                    return $PropertyPath.schema;
+                },
+            },
             pattern: {
                 kind: "Shacl",
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#pattern"),
@@ -3103,18 +2537,45 @@ export var NodeShape;
                     itemType: { kind: "String" },
                 },
             },
-            properties: {
+            qualifiedMaxCount: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#property"),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#qualifiedMaxCount"),
                 type: {
-                    kind: "Set",
+                    kind: "Option",
+                    itemType: { kind: "BigInt" },
+                },
+            },
+            qualifiedMinCount: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#qualifiedMinCount"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "BigInt" },
+                },
+            },
+            qualifiedValueShape: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#qualifiedValueShape"),
+                type: {
+                    kind: "Option",
                     itemType: { kind: "Identifier" },
                 },
             },
-            rdfType: {
+            qualifiedValueShapesDisjoint: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#rdfType"),
-                type: { kind: "Option", itemType: { kind: "Iri" } },
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#qualifiedValueShapesDisjoint"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Boolean" },
+                },
+            },
+            resolve: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://purl.org/shaclmate/ontology#resolve"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Identifier" },
+                },
             },
             severity: {
                 kind: "Shacl",
@@ -3139,11 +2600,6 @@ export var NodeShape;
                     itemType: { kind: "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"),
@@ -3152,7 +2608,10 @@ export var NodeShape;
             targetNodes: {
                 kind: "Shacl",
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetNode"),
-                type: { kind: "Set", itemType: { kind: "Term" } },
+                type: {
+                    kind: "Set",
+                    itemType: { kind: "Term", types: ["NamedNode", "Literal"] },
+                },
             },
             targetObjectsOf: {
                 kind: "Shacl",
@@ -3164,20 +2623,13 @@ export var NodeShape;
                 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" } },
-            },
-            types: {
+            uniqueLang: {
                 kind: "Shacl",
-                path: $RdfVocabularies.rdf.type,
-                type: { kind: "Set", itemType: { kind: "Iri" } },
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#uniqueLang"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Boolean" },
+                },
             },
             xone: {
                 kind: "Shacl",
@@ -3192,11 +2644,11 @@ export var NodeShape;
             },
         },
     };
-    NodeShape._toRdfResource = (parameters) => {
+    PropertyShape._toRdfResource = (parameters) => {
         if (!parameters.ignoreRdfType) {
-            parameters.resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/ns/shacl#NodeShape"), parameters.graph);
+            parameters.resource.add($RdfVocabularies.rdf.type, dataFactory.namedNode("http://www.w3.org/ns/shacl#PropertyShape"), parameters.graph);
         }
-        parameters.resource.add(PropertyShape.schema.properties.and.path, parameters.object.and.toList().flatMap((value) => [
+        parameters.resource.add(NodeShape.schema.properties.and.path, parameters.object.and.toList().flatMap((value) => [
             value.length > 0
                 ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
                     if (itemIndex === 0) {
@@ -3218,57 +2670,38 @@ export var NodeShape;
                 }).listResource.identifier
                 : $RdfVocabularies.rdf.nil,
         ]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.classes.path, parameters.object.classes.flatMap((item) => [item]), parameters.graph);
-        parameters.resource.add(NodeShape.schema.properties.closed.path, parameters.object.closed
-            .toList()
-            .flatMap((value) => [
-            $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
-        ]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.comment.path, parameters.object.comment
+        parameters.resource.add(NodeShape.schema.properties.classes.path, parameters.object.classes.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.comment.path, parameters.object.comment
             .toList()
             .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.datatype.path, parameters.object.datatype.toList(), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.deactivated.path, parameters.object.deactivated
+        parameters.resource.add(NodeShape.schema.properties.datatype.path, parameters.object.datatype.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.deactivated.path, parameters.object.deactivated
             .toList()
             .flatMap((value) => [
             $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
         ]), parameters.graph);
-        parameters.resource.add(NodeShape.schema.properties.discriminantValue.path, parameters.object.discriminantValue
+        parameters.resource.add(PropertyShape.schema.properties.defaultValue.path, parameters.object.defaultValue.toList(), parameters.graph);
+        parameters.resource.add(PropertyShape.schema.properties.description.path, parameters.object.description
             .toList()
             .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
-        parameters.resource.add(NodeShape.schema.properties.extern.path, parameters.object.extern
-            .toList()
-            .flatMap((value) => [
-            $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
-        ]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.flags.path, parameters.object.flags
+        parameters.resource.add(PropertyShape.schema.properties.disjoint.path, parameters.object.disjoint.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(PropertyShape.schema.properties.display.path, $strictEquals(parameters.object.display, false).isLeft()
+            ? [
+                $literalFactory.boolean(parameters.object.display, $RdfVocabularies.xsd.boolean),
+            ]
+            : [], parameters.graph);
+        parameters.resource.add(PropertyShape.schema.properties.equals.path, parameters.object.equals.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.flags.path, parameters.object.flags
             .toList()
             .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
-        parameters.resource.add(NodeShape.schema.properties.fromRdfType.path, parameters.object.fromRdfType.toList(), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.hasValues.path, parameters.object.hasValues.flatMap((item) => [item]), parameters.graph);
-        parameters.resource.add(NodeShape.schema.properties.ignoredProperties.path, parameters.object.ignoredProperties.toList().flatMap((value) => [
-            value.length > 0
-                ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
-                    if (itemIndex === 0) {
-                        currentSubListResource = listResource;
-                    }
-                    else {
-                        const newSubListResource = parameters.resourceSet.resource((() => dataFactory.blankNode())());
-                        currentSubListResource.add($RdfVocabularies.rdf.rest, newSubListResource.identifier, parameters.graph);
-                        currentSubListResource = newSubListResource;
-                    }
-                    currentSubListResource.add($RdfVocabularies.rdf.first, [item], parameters.graph);
-                    if (itemIndex + 1 === list.length) {
-                        currentSubListResource.add($RdfVocabularies.rdf.rest, $RdfVocabularies.rdf.nil, parameters.graph);
-                    }
-                    return { currentSubListResource, listResource };
-                }, {
-                    currentSubListResource: null,
-                    listResource: parameters.resourceSet.resource((() => dataFactory.blankNode())()),
-                }).listResource.identifier
-                : $RdfVocabularies.rdf.nil,
-        ]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.in_.path, parameters.object.in_.toList().flatMap((value) => [
+        parameters.resource.add(PropertyShape.schema.properties.groups.path, parameters.object.groups.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.hasValues.path, parameters.object.hasValues.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(PropertyShape.schema.properties.ignore.path, $strictEquals(parameters.object.ignore, false).isLeft()
+            ? [
+                $literalFactory.boolean(parameters.object.ignore, $RdfVocabularies.xsd.boolean),
+            ]
+            : [], parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.in_.path, parameters.object.in_.toList().flatMap((value) => [
             value.length > 0
                 ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
                     if (itemIndex === 0) {
@@ -3290,11 +2723,11 @@ export var NodeShape;
                 }).listResource.identifier
                 : $RdfVocabularies.rdf.nil,
         ]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.isDefinedBy.path, parameters.object.isDefinedBy.toList(), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.label.path, parameters.object.label
+        parameters.resource.add(NodeShape.schema.properties.isDefinedBy.path, parameters.object.isDefinedBy.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.label.path, parameters.object.label
             .toList()
             .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.languageIn.path, parameters.object.languageIn.toList().flatMap((value) => [
+        parameters.resource.add(NodeShape.schema.properties.languageIn.path, parameters.object.languageIn.toList().flatMap((value) => [
             value.length > 0
                 ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
                     if (itemIndex === 0) {
@@ -3316,32 +2749,47 @@ export var NodeShape;
                 }).listResource.identifier
                 : $RdfVocabularies.rdf.nil,
         ]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.maxExclusive.path, parameters.object.maxExclusive.toList(), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.maxInclusive.path, parameters.object.maxInclusive.toList(), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.maxLength.path, parameters.object.maxLength
+        parameters.resource.add(PropertyShape.schema.properties.lessThan.path, parameters.object.lessThan.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(PropertyShape.schema.properties.lessThanOrEquals.path, parameters.object.lessThanOrEquals.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(PropertyShape.schema.properties.maxCount.path, parameters.object.maxCount
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.bigint(value, $RdfVocabularies.xsd.integer),
+        ]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.maxExclusive.path, parameters.object.maxExclusive.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.maxInclusive.path, parameters.object.maxInclusive.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.maxLength.path, parameters.object.maxLength
             .toList()
             .flatMap((value) => [
             $literalFactory.bigint(value, $RdfVocabularies.xsd.integer),
         ]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.message.path, parameters.object.message
+        parameters.resource.add(NodeShape.schema.properties.message.path, parameters.object.message
             .toList()
             .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.minExclusive.path, parameters.object.minExclusive.toList(), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.minInclusive.path, parameters.object.minInclusive.toList(), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.minLength.path, parameters.object.minLength
+        parameters.resource.add(PropertyShape.schema.properties.minCount.path, parameters.object.minCount
             .toList()
             .flatMap((value) => [
             $literalFactory.bigint(value, $RdfVocabularies.xsd.integer),
         ]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.mutable.path, parameters.object.mutable
+        parameters.resource.add(NodeShape.schema.properties.minExclusive.path, parameters.object.minExclusive.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.minInclusive.path, parameters.object.minInclusive.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.minLength.path, parameters.object.minLength
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.bigint(value, $RdfVocabularies.xsd.integer),
+        ]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.mutable.path, parameters.object.mutable
             .toList()
             .flatMap((value) => [
             $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
         ]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.node.path, parameters.object.node.toList(), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.nodeKind.path, parameters.object.nodeKind.toList(), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.not.path, parameters.object.not.flatMap((item) => [item]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.or.path, parameters.object.or.toList().flatMap((value) => [
+        parameters.resource.add(PropertyShape.schema.properties.name.path, parameters.object.name
+            .toList()
+            .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.node.path, parameters.object.node.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.nodeKind.path, parameters.object.nodeKind.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.not.path, parameters.object.not.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.or.path, parameters.object.or.toList().flatMap((value) => [
             value.length > 0
                 ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
                     if (itemIndex === 0) {
@@ -3363,26 +2811,51 @@ export var NodeShape;
                 }).listResource.identifier
                 : $RdfVocabularies.rdf.nil,
         ]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.pattern.path, parameters.object.pattern
+        parameters.resource.add(PropertyShape.schema.properties.order.path, parameters.object.order
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.number(value, $RdfVocabularies.xsd.double),
+        ]), parameters.graph);
+        parameters.resource.add(PropertyShape.schema.properties.path.path, [
+            $PropertyPath.toRdfResource(parameters.object.path, {
+                graph: parameters.graph,
+                resourceSet: parameters.resourceSet,
+            }).identifier,
+        ], parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.pattern.path, parameters.object.pattern
             .toList()
             .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
-        parameters.resource.add(NodeShape.schema.properties.properties.path, parameters.object.properties.flatMap((item) => [item]), parameters.graph);
-        parameters.resource.add(NodeShape.schema.properties.rdfType.path, parameters.object.rdfType.toList(), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.severity.path, parameters.object.severity.toList(), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.shaclmateName.path, parameters.object.shaclmateName
+        parameters.resource.add(PropertyShape.schema.properties.qualifiedMaxCount.path, parameters.object.qualifiedMaxCount
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.bigint(value, $RdfVocabularies.xsd.integer),
+        ]), parameters.graph);
+        parameters.resource.add(PropertyShape.schema.properties.qualifiedMinCount.path, parameters.object.qualifiedMinCount
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.bigint(value, $RdfVocabularies.xsd.integer),
+        ]), parameters.graph);
+        parameters.resource.add(PropertyShape.schema.properties.qualifiedValueShape.path, parameters.object.qualifiedValueShape.toList(), parameters.graph);
+        parameters.resource.add(PropertyShape.schema.properties.qualifiedValueShapesDisjoint.path, parameters.object.qualifiedValueShapesDisjoint
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
+        ]), parameters.graph);
+        parameters.resource.add(PropertyShape.schema.properties.resolve.path, parameters.object.resolve.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.severity.path, parameters.object.severity.toList(), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.shaclmateName.path, parameters.object.shaclmateName
             .toList()
             .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
-        parameters.resource.add(NodeShape.schema.properties.subClassOf.path, parameters.object.subClassOf.flatMap((item) => [item]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.targetClasses.path, parameters.object.targetClasses.flatMap((item) => [item]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.targetNodes.path, parameters.object.targetNodes.flatMap((item) => [item]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.targetObjectsOf.path, parameters.object.targetObjectsOf.flatMap((item) => [item]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.targetSubjectsOf.path, parameters.object.targetSubjectsOf.flatMap((item) => [item]), parameters.graph);
-        parameters.resource.add(NodeShape.schema.properties.toRdfTypes.path, parameters.object.toRdfTypes.flatMap((item) => [item]), parameters.graph);
-        parameters.resource.add(NodeShape.schema.properties.tsImports.path, parameters.object.tsImports.flatMap((item) => [
-            $literalFactory.string(item),
+        parameters.resource.add(NodeShape.schema.properties.targetClasses.path, parameters.object.targetClasses.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.targetNodes.path, parameters.object.targetNodes.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.targetObjectsOf.path, parameters.object.targetObjectsOf.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(NodeShape.schema.properties.targetSubjectsOf.path, parameters.object.targetSubjectsOf.flatMap((item) => [item]), parameters.graph);
+        parameters.resource.add(PropertyShape.schema.properties.uniqueLang.path, parameters.object.uniqueLang
+            .toList()
+            .flatMap((value) => [
+            $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
         ]), parameters.graph);
-        parameters.resource.add(NodeShape.schema.properties.types.path, parameters.object.types.flatMap((item) => [item]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.xone.path, parameters.object.xone.toList().flatMap((value) => [
+        parameters.resource.add(NodeShape.schema.properties.xone.path, parameters.object.xone.toList().flatMap((value) => [
             value.length > 0
                 ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
                     if (itemIndex === 0) {
@@ -3406,22 +2879,18 @@ export var NodeShape;
         ]), parameters.graph);
         return parameters.resource;
     };
-    NodeShape.toRdfResource = $wrap_ToRdfResourceFunction(NodeShape._toRdfResource);
-    function _propertiesToStrings(_nodeShape) {
-        return $compactRecord({
-            $identifier: _nodeShape.$identifier().toString(),
-            label: _nodeShape.label.map((item) => item.toString()).extract(),
-            shaclmateName: _nodeShape.shaclmateName
-                .map((item) => item.toString())
-                .extract(),
-        });
-    }
-    NodeShape._propertiesToStrings = _propertiesToStrings;
-    function $toString(_nodeShape) {
-        return `NodeShape(${JSON.stringify(_propertiesToStrings(_nodeShape))})`;
-    }
-    NodeShape.$toString = $toString;
-})(NodeShape || (NodeShape = {}));
+    PropertyShape.toRdfResource = $wrap_ToRdfResourceFunction(PropertyShape._toRdfResource);
+    PropertyShape.$toString = (_propertyShape) => `PropertyShape(${JSON.stringify(PropertyShape.toStringRecord(_propertyShape))})`;
+    PropertyShape.toStringRecord = (_propertyShape) => $compactRecord({
+        $identifier: _propertyShape.$identifier().toString(),
+        label: _propertyShape.label.map((item) => item.toString()).extract(),
+        name: _propertyShape.name.map((item) => item.toString()).extract(),
+        path: $PropertyPath.$toString(_propertyShape.path),
+        shaclmateName: _propertyShape.shaclmateName
+            .map((item) => item.toString())
+            .extract(),
+    });
+})(PropertyShape || (PropertyShape = {}));
 export var Shape;
 (function (Shape) {
     Shape.$toString = (value) => {
@@ -3440,26 +2909,18 @@ export var Shape;
         ...options,
         ignoreRdfType: false,
     }));
-    Shape.fromRdfResourceValues = ((values, _options) => values.chain((values) => values.chainMap((value) => {
-        const valueAsValues = Right(value.toValues());
+    Shape.fromRdfResourceValues = ((values, options) => values.chainMap((value) => {
+        const valueAsValues = value.toValues();
         return NodeShape.fromRdfResourceValues(valueAsValues, {
-            context: _options.context,
-            graph: _options.graph,
-            ignoreRdfType: false,
-            preferredLanguages: _options.preferredLanguages,
-            propertyPath: _options.propertyPath,
-            resource: _options.resource,
+            ...options,
+            schema: options.schema.members["NodeShape"].type,
         })
             .altLazy(() => PropertyShape.fromRdfResourceValues(valueAsValues, {
-            context: _options.context,
-            graph: _options.graph,
-            ignoreRdfType: false,
-            preferredLanguages: _options.preferredLanguages,
-            propertyPath: _options.propertyPath,
-            resource: _options.resource,
+            ...options,
+            schema: options.schema.members["PropertyShape"].type,
         }))
             .chain((values) => values.head());
-    })));
+    }));
     let Identifier;
     (function (Identifier) {
         Identifier.parse = $parseIdentifier;
@@ -3527,7 +2988,10 @@ export var Shape;
             hasValues: {
                 kind: "Shacl",
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#hasValue"),
-                type: { kind: "Set", itemType: { kind: "Term" } },
+                type: {
+                    kind: "Set",
+                    itemType: { kind: "Term", types: ["NamedNode", "Literal"] },
+                },
             },
             in_: {
                 kind: "Shacl",
@@ -3536,7 +3000,10 @@ export var Shape;
                     kind: "Option",
                     itemType: {
                         kind: "List",
-                        itemType: { kind: "Term" },
+                        itemType: {
+                            kind: "Term",
+                            types: ["NamedNode", "Literal"],
+                        },
                     },
                 },
             },
@@ -3715,7 +3182,10 @@ export var Shape;
             targetNodes: {
                 kind: "Shacl",
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetNode"),
-                type: { kind: "Set", itemType: { kind: "Term" } },
+                type: {
+                    kind: "Set",
+                    itemType: { kind: "Term", types: ["NamedNode", "Literal"] },
+                },
             },
             targetObjectsOf: {
                 kind: "Shacl",
@@ -3802,42 +3272,26 @@ export var $Object;
         ...options,
         ignoreRdfType: false,
     }));
-    $Object.fromRdfResourceValues = ((values, _options) => values.chain((values) => values.chainMap((value) => {
-        const valueAsValues = Right(value.toValues());
+    $Object.fromRdfResourceValues = ((values, options) => values.chainMap((value) => {
+        const valueAsValues = value.toValues();
         return NodeShape.fromRdfResourceValues(valueAsValues, {
-            context: _options.context,
-            graph: _options.graph,
-            ignoreRdfType: false,
-            preferredLanguages: _options.preferredLanguages,
-            propertyPath: _options.propertyPath,
-            resource: _options.resource,
+            ...options,
+            schema: options.schema.members["NodeShape"].type,
         })
             .altLazy(() => Ontology.fromRdfResourceValues(valueAsValues, {
-            context: _options.context,
-            graph: _options.graph,
-            ignoreRdfType: false,
-            preferredLanguages: _options.preferredLanguages,
-            propertyPath: _options.propertyPath,
-            resource: _options.resource,
+            ...options,
+            schema: options.schema.members["Ontology"].type,
         }))
             .altLazy(() => PropertyGroup.fromRdfResourceValues(valueAsValues, {
-            context: _options.context,
-            graph: _options.graph,
-            ignoreRdfType: false,
-            preferredLanguages: _options.preferredLanguages,
-            propertyPath: _options.propertyPath,
-            resource: _options.resource,
+            ...options,
+            schema: options.schema.members["PropertyGroup"].type,
         }))
             .altLazy(() => PropertyShape.fromRdfResourceValues(valueAsValues, {
-            context: _options.context,
-            graph: _options.graph,
-            ignoreRdfType: false,
-            preferredLanguages: _options.preferredLanguages,
-            propertyPath: _options.propertyPath,
-            resource: _options.resource,
+            ...options,
+            schema: options.schema.members["PropertyShape"].type,
         }))
             .chain((values) => values.head());
-    })));
+    }));
     let Identifier;
     (function (Identifier) {
         Identifier.parse = $parseIdentifier;