@shaclmate/shacl-ast 4.0.40 → 4.0.42

package/dist/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.
  */
@@ -15,11 +25,6 @@ function $compactRecord(record) {
         return definedProperties;
     }, {});
 }
-function $convertToArray(convertToItem, _readonly) {
-    return (value) => (typeof value === "undefined"
-        ? Either.of([])
-        : Either.sequence(value.map(convertToItem)));
-}
 function $convertToIdentifier(value) {
     switch (typeof value) {
         case "object":
@@ -56,6 +61,9 @@ function $convertToIri(value) {
             return Either.of(dataFactory.namedNode(value));
     }
 }
+function $convertToList(convertToItem, _readonly) {
+    return (value) => Either.sequence(value.map(convertToItem));
+}
 function $convertToLiteral(value) {
     if (typeof value === "object") {
         if (value instanceof Date) {
@@ -80,6 +88,19 @@ function $convertToMaybe(convertToItem) {
         return convertToItem(value).map(Maybe.of);
     };
 }
+function $convertToScalarSet(convertToItem, _readonly) {
+    return (value) => {
+        if (typeof value === "undefined") {
+            return Either.of([]);
+        }
+        if (Array.isArray(value)) {
+            return Either.sequence(value.map(convertToItem));
+        }
+        return convertToItem(value).map((value) => [
+            value,
+        ]);
+    };
+}
 function $ensureRdfResourceType(resource, types, options) {
     return resource
         .value($RdfVocabularies.rdf.type, options)
@@ -94,27 +115,13 @@ function $ensureRdfResourceType(resource, types, options) {
         return Left(new Error(`${resource.identifier} has unexpected RDF type (actual: ${actualRdfType}, expected one of ${types})`));
     });
 }
-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);
@@ -122,7 +129,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") ||
@@ -146,50 +183,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 = {};
@@ -202,9 +236,105 @@ 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());
+}
+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) {
@@ -249,615 +379,391 @@ function $wrap_ToRdfResourceFunction(_toRdfResourceFunction) {
         return resource;
     };
 }
-export var PropertyShape;
-(function (PropertyShape) {
-    function create(parameters) {
-        return $sequenceRecord({
-            $identifier: $convertToIdentifierProperty(parameters.$identifier),
-            and: $convertToMaybe($convertToArray($convertToIdentifier, true))(parameters.and).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(PropertyShape.schema.properties.and.type, value)),
-            classes: $convertToArray(($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)),
-            flags: $convertToArray($identityConversionFunction, true)(parameters.flags).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.flags.type, value)),
-            groups: $convertToArray($convertToIdentifier, true)(parameters.groups).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.groups.type, value)),
-            hasValues: $convertToArray($identityConversionFunction, true)(parameters.hasValues).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.hasValues.type, value)),
-            in_: $convertToMaybe($convertToArray($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($convertToArray($identityConversionFunction, true))(parameters.languageIn).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(PropertyShape.schema.properties.languageIn.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)),
-            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)),
-            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: $convertToArray($convertToIdentifier, true)(parameters.not).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.not.type, value)),
-            or: $convertToMaybe($convertToArray($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),
-            patterns: $convertToArray($identityConversionFunction, true)(parameters.patterns).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.patterns.type, value)),
-            uniqueLang: $convertToMaybe($identityConversionFunction)(parameters.uniqueLang).chain((value) => $validateMaybe($identityValidationFunction)(PropertyShape.schema.properties.uniqueLang.type, value)),
-            xone: $convertToMaybe($convertToArray($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)),
+        flags: $convertToMaybe($identityConversionFunction)(parameters?.flags).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.flags.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)),
+        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)),
+        severity: $convertToMaybe(($convertToIri))(parameters?.severity).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.severity.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)),
+        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)),
+        }),
+        flags: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.flags,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($stringFromRdfResourceValues)),
+        }),
+        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)),
+        }),
+        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),
+        }),
+        severity: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: NodeShape.schema.properties.severity,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        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)),
+        }),
+        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(),
-                    })),
-            }),
-            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.toArray())
-                    .map((valuesArray) => Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.flags.path,
-                    value: valuesArray,
-                })),
-            }),
-            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(),
-                    })),
-            }),
-            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(),
-                    })),
-            }),
-            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(),
-                    })),
-            }),
-            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,
-                }),
-            }),
-            patterns: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: PropertyShape.schema.properties.patterns,
-                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: PropertyShape.schema.properties.patterns.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",
@@ -879,6 +785,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"),
@@ -900,36 +814,32 @@ 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: {
+            flags: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#description"),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#flags"),
                 type: {
                     kind: "Option",
                     itemType: { kind: "String" },
                 },
             },
-            flags: {
-                kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#flags"),
-                type: { kind: "Set", itemType: { kind: "String" } },
-            },
-            groups: {
+            hasValues: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#group"),
+                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",
@@ -938,7 +848,10 @@ export var PropertyShape;
                     kind: "Option",
                     itemType: {
                         kind: "List",
-                        itemType: { kind: "Term" },
+                        itemType: {
+                            kind: "Term",
+                            types: ["NamedNode", "Literal"],
+                        },
                     },
                 },
             },
@@ -969,14 +882,6 @@ export var PropertyShape;
                     },
                 },
             },
-            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"),
@@ -1001,12 +906,12 @@ export var PropertyShape;
                     itemType: { kind: "BigInt" },
                 },
             },
-            minCount: {
+            message: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minCount"),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#message"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "BigInt" },
+                    itemType: { kind: "String" },
                 },
             },
             minExclusive: {
@@ -1033,14 +938,6 @@ export var PropertyShape;
                     itemType: { kind: "BigInt" },
                 },
             },
-            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"),
@@ -1086,31 +983,70 @@ export var PropertyShape;
                     },
                 },
             },
-            order: {
+            pattern: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#order"),
-                type: { kind: "Option", itemType: { kind: "Float" } },
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#pattern"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
             },
-            path: {
+            properties: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#path"),
-                get type() {
-                    return $PropertyPath.schema;
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#property"),
+                type: {
+                    kind: "Set",
+                    itemType: { kind: "Identifier" },
                 },
             },
-            patterns: {
+            severity: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#pattern"),
-                type: { kind: "Set", itemType: { kind: "String" } },
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#severity"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "Iri",
+                        in: [
+                            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"),
+                        ],
+                    },
+                },
             },
-            uniqueLang: {
+            subClassOf: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#uniqueLang"),
+                path: $RdfVocabularies.rdfs.subClassOf,
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            targetClasses: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetClass"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            targetNodes: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetNode"),
                 type: {
-                    kind: "Option",
-                    itemType: { kind: "Boolean" },
+                    kind: "Set",
+                    itemType: { kind: "Term", types: ["NamedNode", "Literal"] },
                 },
             },
+            targetObjectsOf: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetObjectsOf"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            targetSubjectsOf: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetSubjectsOf"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            types: {
+                kind: "Shacl",
+                path: $RdfVocabularies.rdf.type,
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
             xone: {
                 kind: "Shacl",
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#xone"),
@@ -1124,11 +1060,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) {
@@ -1150,24 +1086,48 @@ 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.flags.path, parameters.object.flags
             .toList()
             .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.flags.path, parameters.object.flags.flatMap((item) => [$literalFactory.string(item)]), 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.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) {
@@ -1189,11 +1149,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) {
@@ -1215,37 +1175,27 @@ export var PropertyShape;
                 }).listResource.identifier
                 : $RdfVocabularies.rdf.nil,
         ]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.maxCount.path, parameters.object.maxCount
+        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.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.message.path, parameters.object.message
             .toList()
-            .flatMap((value) => [
-            $literalFactory.bigint(value, $RdfVocabularies.xsd.integer),
-        ]), 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
+            .flatMap((value) => [$literalFactory.string(value)]), parameters.graph);
+        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.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) {
@@ -1267,26 +1217,18 @@ 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.patterns.path, parameters.object.patterns.flatMap((item) => [
-            $literalFactory.string(item),
-        ]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.uniqueLang.path, parameters.object.uniqueLang
+        parameters.resource.add(NodeShape.schema.properties.pattern.path, parameters.object.pattern
             .toList()
-            .flatMap((value) => [
-            $literalFactory.boolean(value, $RdfVocabularies.xsd.boolean),
-        ]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.xone.path, parameters.object.xone.toList().flatMap((value) => [
+            .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.severity.path, parameters.object.severity.toList(), parameters.graph);
+        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.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) {
@@ -1310,101 +1252,78 @@ 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),
-        });
-    }
-    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(),
+    });
+})(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",
@@ -1428,111 +1347,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",
@@ -1556,600 +1454,530 @@ 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($convertToArray($convertToIdentifier, true))(parameters?.and).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(PropertyShape.schema.properties.and.type, value)),
-            classes: $convertToArray(($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)),
-            flags: $convertToArray($identityConversionFunction, true)(parameters?.flags).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.flags.type, value)),
-            hasValues: $convertToArray($identityConversionFunction, true)(parameters?.hasValues).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.hasValues.type, value)),
-            ignoredProperties: $convertToMaybe($convertToArray(($convertToIri), true))(parameters?.ignoredProperties).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(NodeShape.schema.properties.ignoredProperties.type, value)),
-            in_: $convertToMaybe($convertToArray($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($convertToArray($identityConversionFunction, true))(parameters?.languageIn).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(PropertyShape.schema.properties.languageIn.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)),
-            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)),
-            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: $convertToArray($convertToIdentifier, true)(parameters?.not).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.not.type, value)),
-            or: $convertToMaybe($convertToArray($convertToIdentifier, true))(parameters?.or).chain((value) => $validateMaybe($validateArray($identityValidationFunction, true))(PropertyShape.schema.properties.or.type, value)),
-            patterns: $convertToArray($identityConversionFunction, true)(parameters?.patterns).chain((value) => $validateArray($identityValidationFunction, true)(PropertyShape.schema.properties.patterns.type, value)),
-            properties: $convertToArray($convertToIdentifier, true)(parameters?.properties).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.properties.type, value)),
-            subClassOf: $convertToArray(($convertToIri), true)(parameters?.subClassOf).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.subClassOf.type, value)),
-            types: $convertToArray(($convertToIri), true)(parameters?.types).chain((value) => $validateArray($identityValidationFunction, true)(NodeShape.schema.properties.types.type, value)),
-            xone: $convertToMaybe($convertToArray($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)),
+        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)),
+        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)),
+        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)),
+        severity: $convertToMaybe(($convertToIri))(parameters.severity).chain((value) => $validateMaybe($identityValidationFunction)(NodeShape.schema.properties.severity.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)),
+        }),
+        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)),
+        }),
+        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)),
+        }),
+        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)),
+        }),
+        severity: $shaclPropertyFromRdf({
+            context: _$options.context,
+            graph: _$options.graph,
+            focusResource: $resource,
+            ignoreRdfType: true,
+            preferredLanguages: _$options.preferredLanguages,
+            propertySchema: PropertyShape.schema.properties.severity,
+            typeFromRdfResourceValues: $maybeFromRdfResourceValues(($iriFromRdfResourceValues)),
+        }),
+        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(),
-                    })),
-            }),
-            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.toArray())
-                    .map((valuesArray) => Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.flags.path,
-                    value: valuesArray,
-                })),
-            }),
-            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(),
-                    })),
-            }),
-            maxCount: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.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: 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(),
-                    })),
-            }),
-            minCount: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.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: 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(),
-                    })),
-            }),
-            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(),
-                    })),
-            }),
-            patterns: $shaclPropertyFromRdf({
-                graph: _$options.graph,
-                resource: $resource,
-                propertySchema: NodeShape.schema.properties.patterns,
-                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: PropertyShape.schema.properties.patterns.path,
-                    value: valuesArray,
-                })),
-            }),
-            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,
-                })),
-            }),
-            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,
-                })),
-            }),
-            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",
@@ -2171,54 +1999,75 @@ export var NodeShape;
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#class"),
                 type: { kind: "Set", itemType: { kind: "Iri" } },
             },
-            closed: {
+            comment: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#closed"),
+                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
+            },
+            datatype: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#datatype"),
+                type: { kind: "Option", itemType: { kind: "Iri" } },
+            },
+            deactivated: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#deactivated"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Boolean" },
+                },
+            },
+            defaultValue: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#defaultValue"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "Boolean" },
+                    itemType: { kind: "Term", types: ["NamedNode", "Literal"] },
                 },
             },
-            comment: {
+            description: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/2000/01/rdf-schema#comment"),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#description"),
                 type: {
                     kind: "Option",
                     itemType: { kind: "String" },
                 },
             },
-            datatype: {
+            disjoint: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#datatype"),
-                type: { kind: "Option", itemType: { kind: "Iri" } },
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#disjoint"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
             },
-            deactivated: {
+            equals: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#deactivated"),
+                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"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "Boolean" },
+                    itemType: { kind: "String" },
                 },
             },
-            flags: {
+            groups: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#flags"),
-                type: { kind: "Set", itemType: { kind: "String" } },
+                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" } },
-            },
-            ignoredProperties: {
-                kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#ignoredProperties"),
                 type: {
-                    kind: "Option",
-                    itemType: {
-                        kind: "List",
-                        itemType: { kind: "Iri" },
-                    },
+                    kind: "Set",
+                    itemType: { kind: "Term", types: ["NamedNode", "Literal"] },
                 },
             },
             in_: {
@@ -2228,7 +2077,10 @@ export var NodeShape;
                     kind: "Option",
                     itemType: {
                         kind: "List",
-                        itemType: { kind: "Term" },
+                        itemType: {
+                            kind: "Term",
+                            types: ["NamedNode", "Literal"],
+                        },
                     },
                 },
             },
@@ -2259,6 +2111,16 @@ 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"),
@@ -2291,6 +2153,14 @@ export var NodeShape;
                     itemType: { kind: "BigInt" },
                 },
             },
+            message: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#message"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
+            },
             minCount: {
                 kind: "Shacl",
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minCount"),
@@ -2323,6 +2193,14 @@ export var NodeShape;
                     itemType: { kind: "BigInt" },
                 },
             },
+            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"),
@@ -2368,29 +2246,104 @@ export var NodeShape;
                     },
                 },
             },
-            patterns: {
+            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"),
-                type: { kind: "Set", itemType: { kind: "String" } },
+                type: {
+                    kind: "Option",
+                    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" },
                 },
             },
-            subClassOf: {
+            qualifiedValueShapesDisjoint: {
                 kind: "Shacl",
-                path: $RdfVocabularies.rdfs.subClassOf,
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#qualifiedValueShapesDisjoint"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Boolean" },
+                },
+            },
+            severity: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#severity"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "Iri",
+                        in: [
+                            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"),
+                        ],
+                    },
+                },
+            },
+            targetClasses: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetClass"),
                 type: { kind: "Set", itemType: { kind: "Iri" } },
             },
-            types: {
+            targetNodes: {
                 kind: "Shacl",
-                path: $RdfVocabularies.rdf.type,
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetNode"),
+                type: {
+                    kind: "Set",
+                    itemType: { kind: "Term", types: ["NamedNode", "Literal"] },
+                },
+            },
+            targetObjectsOf: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetObjectsOf"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            targetSubjectsOf: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetSubjectsOf"),
                 type: { kind: "Set", itemType: { kind: "Iri" } },
             },
+            uniqueLang: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#uniqueLang"),
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "Boolean" },
+                },
+            },
             xone: {
                 kind: "Shacl",
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#xone"),
@@ -2404,11 +2357,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) {
@@ -2430,46 +2383,28 @@ 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
+        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(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.comment.path, parameters.object.comment
+        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(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(PropertyShape.schema.properties.disjoint.path, parameters.object.disjoint.flatMap((item) => [item]), 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.boolean(value, $RdfVocabularies.xsd.boolean),
-        ]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.flags.path, parameters.object.flags.flatMap((item) => [$literalFactory.string(item)]), 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) => [
+            .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(NodeShape.schema.properties.hasValues.path, parameters.object.hasValues.flatMap((item) => [item]), 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) {
@@ -2491,11 +2426,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) {
@@ -2517,34 +2452,42 @@ export var NodeShape;
                 }).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(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.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) {
@@ -2566,13 +2509,47 @@ export var NodeShape;
                 }).listResource.identifier
                 : $RdfVocabularies.rdf.nil,
         ]), parameters.graph);
-        parameters.resource.add(PropertyShape.schema.properties.patterns.path, parameters.object.patterns.flatMap((item) => [
-            $literalFactory.string(item),
+        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(NodeShape.schema.properties.properties.path, parameters.object.properties.flatMap((item) => [item]), parameters.graph);
-        parameters.resource.add(NodeShape.schema.properties.subClassOf.path, parameters.object.subClassOf.flatMap((item) => [item]), 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(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(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(NodeShape.schema.properties.severity.path, parameters.object.severity.toList(), 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(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.xone.path, parameters.object.xone.toList().flatMap((value) => [
             value.length > 0
                 ? value.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
                     if (itemIndex === 0) {
@@ -2596,19 +2573,15 @@ 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(),
-        });
-    }
-    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),
+    });
+})(PropertyShape || (PropertyShape = {}));
 export var Shape;
 (function (Shape) {
     Shape.$toString = (value) => {
@@ -2627,26 +2600,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;
@@ -2706,12 +2671,18 @@ export var Shape;
             flags: {
                 kind: "Shacl",
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#flags"),
-                type: { kind: "Set", itemType: { kind: "String" } },
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
             },
             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",
@@ -2720,7 +2691,10 @@ export var Shape;
                     kind: "Option",
                     itemType: {
                         kind: "List",
-                        itemType: { kind: "Term" },
+                        itemType: {
+                            kind: "Term",
+                            types: ["NamedNode", "Literal"],
+                        },
                     },
                 },
             },
@@ -2751,14 +2725,6 @@ export var Shape;
                     },
                 },
             },
-            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"),
@@ -2783,12 +2749,12 @@ export var Shape;
                     itemType: { kind: "BigInt" },
                 },
             },
-            minCount: {
+            message: {
                 kind: "Shacl",
-                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#minCount"),
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#message"),
                 type: {
                     kind: "Option",
-                    itemType: { kind: "BigInt" },
+                    itemType: { kind: "String" },
                 },
             },
             minExclusive: {
@@ -2860,10 +2826,51 @@ export var Shape;
                     },
                 },
             },
-            patterns: {
+            pattern: {
                 kind: "Shacl",
                 path: dataFactory.namedNode("http://www.w3.org/ns/shacl#pattern"),
-                type: { kind: "Set", itemType: { kind: "String" } },
+                type: {
+                    kind: "Option",
+                    itemType: { kind: "String" },
+                },
+            },
+            severity: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#severity"),
+                type: {
+                    kind: "Option",
+                    itemType: {
+                        kind: "Iri",
+                        in: [
+                            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"),
+                        ],
+                    },
+                },
+            },
+            targetClasses: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetClass"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            targetNodes: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetNode"),
+                type: {
+                    kind: "Set",
+                    itemType: { kind: "Term", types: ["NamedNode", "Literal"] },
+                },
+            },
+            targetObjectsOf: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetObjectsOf"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
+            },
+            targetSubjectsOf: {
+                kind: "Shacl",
+                path: dataFactory.namedNode("http://www.w3.org/ns/shacl#targetSubjectsOf"),
+                type: { kind: "Set", itemType: { kind: "Iri" } },
             },
             xone: {
                 kind: "Shacl",
@@ -2940,42 +2947,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;