npm - @shaclmate/compiler - Versions diffs - 4.0.31 → 4.0.33 - Mend

@shaclmate/compiler 4.0.31 → 4.0.33

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/dist/input/generated.js CHANGED Viewed

@@ -255,6 +255,17 @@ var $RdfVocabularies;
         xsd.unsignedShort = dataFactory.namedNode("http://www.w3.org/2001/XMLSchema#unsignedShort");
     })(xsd = $RdfVocabularies.xsd || ($RdfVocabularies.xsd = {}));
 })($RdfVocabularies || ($RdfVocabularies = {}));
+function $sequenceRecord(record) {
+    const result = {};
+    for (const key of globalThis.Object.keys(record)) {
+        const either = record[key];
+        if (either.isLeft()) {
+            return either;
+        }
+        result[key] = either.extract();
+    }
+    return Right(result);
+}
 function $shaclPropertyFromRdf({ graph, propertySchema, resource, typeFromRdf, }) {
     return typeFromRdf(Right(resource.values(propertySchema.path, { graph, unique: true }))).chain((values) => values.head());
 }
@@ -905,7 +916,7 @@ export var PropertyShape;
         else {
             xone = parameters.xone;
         }
-        return {
+        const $object = {
             $identifier,
             $type,
             and,
@@ -945,6 +956,10 @@ export var PropertyShape;
             uniqueLang,
             xone,
         };
+        if (!globalThis.Object.prototype.hasOwnProperty.call($object, "toString")) {
+            $object.toString = $toString;
+        }
+        return $object;
     }
     PropertyShape.create = create;
     let Identifier;
@@ -1123,758 +1138,604 @@ export var PropertyShape;
                 }
                 return Left(new Error(`${$resource.identifier} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/ns/shacl#PropertyShape)`));
             })
-            : Right(true)).chain((_rdfTypeCheck) => 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())
-            .chain(($identifier) => $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(),
-                })),
-        }).chain((and) => $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,
-            })),
-        }).chain((classes) => $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(),
-                })),
-        }).chain((comment) => $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(),
-                })),
-        }).chain((datatype) => $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(),
-                })),
-        }).chain((deactivated) => $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(),
-                })),
-        }).chain((defaultValue) => $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(),
-                })),
-        }).chain((description) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: PropertyShape.schema.properties.display,
-            typeFromRdf: (resourceValues) => resourceValues
-                .map((values) => values.length > 0
-                ? values
-                : new Resource.Value({
-                    dataFactory: dataFactory,
-                    focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.display
-                        .path,
-                    term: dataFactory.literal("false", $RdfVocabularies.xsd.boolean),
-                }).toValues())
-                .chain((values) => values.chainMap((value) => value.toBoolean())),
-        }).chain((display) => $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({
+            : Right(true)).chain((_rdfTypeCheck) => $sequenceRecord({
+            $identifier: Right(new Resource.Value({
+                dataFactory: dataFactory,
                 focusResource: $resource,
-                propertyPath: PropertyShape.schema.properties.flags
-                    .path,
-                value: valuesArray,
-            })),
-        }).chain((flags) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: PropertyShape.schema.properties.groups,
-            typeFromRdf: (resourceValues) => resourceValues
+                propertyPath: $RdfVocabularies.rdf.subject,
+                term: $resource.identifier,
+            }).toValues())
                 .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,
-            })),
-        }).chain((groups) => $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,
-            })),
-        }).chain((hasValues) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: PropertyShape.schema.properties.in_,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toList({
+                .chain((values) => values.head()),
+            and: $shaclPropertyFromRdf({
                 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(),
-                })),
-        }).chain((in_) => $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(),
-                })),
-        }).chain((isDefinedBy) => $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({
+                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.label.path,
-                    value: Maybe.empty(),
-                })),
-        }).chain((label) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: PropertyShape.schema.properties.languageIn,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toList({
+                    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,
-            })))
-                .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(),
-                })),
-        }).chain((languageIn) => $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(),
-                })),
-        }).chain((maxCount) => $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(),
-                })),
-        }).chain((maxExclusive) => $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(),
-                })),
-        }).chain((maxInclusive) => $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(),
-                })),
-        }).chain((maxLength) => $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(),
-                })),
-        }).chain((minCount) => $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(),
-                })),
-        }).chain((minExclusive) => $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(),
-                })),
-        }).chain((minInclusive) => $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(),
-                })),
-        }).chain((minLength) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: PropertyShape.schema.properties
-                .mutable,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toBoolean()))
-                .map((values) => values.length >
-                0
-                ? values.map((value) => Maybe.of(value))
-                : Resource.Values.fromValue({
+                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
-                        .mutable
-                        .path,
-                    value: Maybe.empty(),
+                    propertyPath: PropertyShape.schema.properties.classes.path,
+                    value: valuesArray,
                 })),
-        }).chain((mutable) => $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({
+            }),
+            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(),
+                    })),
+            }),
+            display: $shaclPropertyFromRdf({
+                graph: _$options.graph,
+                resource: $resource,
+                propertySchema: PropertyShape.schema.properties.display,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .map((values) => values.length > 0
+                    ? values
+                    : new Resource.Value({
+                        dataFactory: dataFactory,
+                        focusResource: $resource,
+                        propertyPath: PropertyShape.schema.properties.display.path,
+                        term: dataFactory.literal("false", $RdfVocabularies.xsd.boolean),
+                    }).toValues())
+                    .chain((values) => values.chainMap((value) => value.toBoolean())),
+            }),
+            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
-                        .name
-                        .path,
-                    value: Maybe.empty(),
+                    propertyPath: PropertyShape.schema.properties.flags.path,
+                    value: valuesArray,
                 })),
-        }).chain((name) => $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({
+            }),
+            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
-                        .node
-                        .path,
-                    value: Maybe.empty(),
+                    propertyPath: PropertyShape.schema.properties.groups.path,
+                    value: valuesArray,
                 })),
-        }).chain((node) => $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({
+            }),
+            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
-                        .nodeKind
-                        .path,
-                    value: Maybe.empty(),
+                    propertyPath: PropertyShape.schema.properties.hasValues.path,
+                    value: valuesArray,
                 })),
-        }).chain((nodeKind) => $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,
-            })),
-        }).chain((not) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: PropertyShape.schema
-                .properties
-                .or,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toList({
+            }),
+            in_: $shaclPropertyFromRdf({
                 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({
+                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
-                        .or
-                        .path,
-                    value: Maybe.empty(),
-                })),
-        }).chain((or) => $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({
+                    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
-                        .order
-                        .path,
-                    value: Maybe.empty(),
-                })),
-        }).chain((order) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: PropertyShape.schema
-                .properties
-                .path,
-            typeFromRdf: (resourceValues) => $PropertyPath.fromRdfResourceValues(resourceValues, {
-                context: _$options.context,
+                    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,
-                preferredLanguages: _$options.preferredLanguages,
-                objectSet: _$options.objectSet,
                 resource: $resource,
-                ignoreRdfType: true,
-                propertyPath: PropertyShape
-                    .schema
-                    .properties
-                    .path
-                    .path,
+                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(),
+                    })),
             }),
-        }).chain((path) => $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,
-            })),
-        }).chain((patterns) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: PropertyShape.schema
-                .properties
-                .resolve,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toIdentifier()))
-                .map((values) => values.length >
-                0
-                ? values.map((value) => Maybe.of(value))
-                : Resource.Values.fromValue({
+            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(),
+                    })),
+            }),
+            mutable: $shaclPropertyFromRdf({
+                graph: _$options.graph,
+                resource: $resource,
+                propertySchema: PropertyShape.schema.properties.mutable,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .chain((values) => values.chainMap((value) => value.toBoolean()))
+                    .map((values) => values.length > 0
+                    ? values.map((value) => Maybe.of(value))
+                    : Resource.Values.fromValue({
+                        focusResource: $resource,
+                        propertyPath: PropertyShape.schema.properties.mutable.path,
+                        value: Maybe.empty(),
+                    })),
+            }),
+            name: $shaclPropertyFromRdf({
+                graph: _$options.graph,
+                resource: $resource,
+                propertySchema: PropertyShape.schema.properties.name,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
+                    .chain((values) => values.chainMap((value) => value.toString()))
+                    .map((values) => values.length > 0
+                    ? values.map((value) => Maybe.of(value))
+                    : Resource.Values.fromValue({
+                        focusResource: $resource,
+                        propertyPath: PropertyShape.schema.properties.name.path,
+                        value: Maybe.empty(),
+                    })),
+            }),
+            node: $shaclPropertyFromRdf({
+                graph: _$options.graph,
+                resource: $resource,
+                propertySchema: PropertyShape.schema.properties.node,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .chain((values) => values.chainMap((value) => value.toIdentifier()))
+                    .map((values) => values.length > 0
+                    ? values.map((value) => Maybe.of(value))
+                    : Resource.Values.fromValue({
+                        focusResource: $resource,
+                        propertyPath: PropertyShape.schema.properties.node.path,
+                        value: Maybe.empty(),
+                    })),
+            }),
+            nodeKind: $shaclPropertyFromRdf({
+                graph: _$options.graph,
+                resource: $resource,
+                propertySchema: PropertyShape.schema.properties.nodeKind,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .chain((values) => values.chainMap((value) => value.toIri([
+                    dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNode"),
+                    dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNodeOrIRI"),
+                    dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNodeOrLiteral"),
+                    dataFactory.namedNode("http://www.w3.org/ns/shacl#IRI"),
+                    dataFactory.namedNode("http://www.w3.org/ns/shacl#IRIOrLiteral"),
+                    dataFactory.namedNode("http://www.w3.org/ns/shacl#Literal"),
+                ])))
+                    .map((values) => values.length > 0
+                    ? values.map((value) => Maybe.of(value))
+                    : Resource.Values.fromValue({
+                        focusResource: $resource,
+                        propertyPath: PropertyShape.schema.properties.nodeKind.path,
+                        value: Maybe.empty(),
+                    })),
+            }),
+            not: $shaclPropertyFromRdf({
+                graph: _$options.graph,
+                resource: $resource,
+                propertySchema: PropertyShape.schema.properties.not,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .chain((values) => values.chainMap((value) => value.toIdentifier()))
+                    .map((values) => values.toArray())
+                    .map((valuesArray) => Resource.Values.fromValue({
                     focusResource: $resource,
-                    propertyPath: PropertyShape
-                        .schema
-                        .properties
-                        .resolve
-                        .path,
-                    value: Maybe.empty(),
+                    propertyPath: PropertyShape.schema.properties.not.path,
+                    value: valuesArray,
                 })),
-        }).chain((resolve) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: PropertyShape.schema
-                .properties
-                .shaclmateName,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                .chain((values) => values.chainMap((value) => value.toString()))
-                .map((values) => values.length >
-                0
-                ? values.map((value) => Maybe.of(value))
-                : Resource.Values.fromValue({
+            }),
+            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
-                        .shaclmateName
-                        .path,
-                    value: Maybe.empty(),
-                })),
-        }).chain((shaclmateName) => $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({
+                    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,
+                    objectSet: _$options.objectSet,
+                    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
-                        .uniqueLang
-                        .path,
-                    value: Maybe.empty(),
+                    propertyPath: PropertyShape.schema.properties.patterns.path,
+                    value: valuesArray,
                 })),
-        }).chain((uniqueLang) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: PropertyShape.schema
-                .properties
-                .xone,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toList({
+            }),
+            resolve: $shaclPropertyFromRdf({
                 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({
+                resource: $resource,
+                propertySchema: PropertyShape.schema.properties.resolve,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .chain((values) => values.chainMap((value) => value.toIdentifier()))
+                    .map((values) => values.length > 0
+                    ? values.map((value) => Maybe.of(value))
+                    : Resource.Values.fromValue({
+                        focusResource: $resource,
+                        propertyPath: PropertyShape.schema.properties.resolve.path,
+                        value: Maybe.empty(),
+                    })),
+            }),
+            shaclmateName: $shaclPropertyFromRdf({
+                graph: _$options.graph,
+                resource: $resource,
+                propertySchema: PropertyShape.schema.properties.shaclmateName,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
+                    .chain((values) => values.chainMap((value) => value.toString()))
+                    .map((values) => values.length > 0
+                    ? values.map((value) => Maybe.of(value))
+                    : Resource.Values.fromValue({
+                        focusResource: $resource,
+                        propertyPath: PropertyShape.schema.properties.shaclmateName.path,
+                        value: Maybe.empty(),
+                    })),
+            }),
+            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,
-                    value: Maybe.empty(),
-                })),
-        }).map((xone) => create({
-            $identifier,
-            and,
-            classes,
-            comment,
-            datatype,
-            deactivated,
-            defaultValue,
-            description,
-            display,
-            flags,
-            groups,
-            hasValues,
-            in_,
-            isDefinedBy,
-            label,
-            languageIn,
-            maxCount,
-            maxExclusive,
-            maxInclusive,
-            maxLength,
-            minCount,
-            minExclusive,
-            minInclusive,
-            minLength,
-            mutable,
-            name,
-            node,
-            nodeKind,
-            not,
-            or,
-            order,
-            path,
-            patterns,
-            resolve,
-            shaclmateName,
-            uniqueLang,
-            xone,
-        })))))))))))))))))))))))))))))))))))))));
+                    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(),
+                    })),
+            }),
+        }).map((properties) => create(properties)));
     };
     PropertyShape.fromRdfResource = $wrap_FromRdfResourceFunction(PropertyShape._fromRdfResource);
     PropertyShape.fromRdfResourceValues = (values, options) => values.chain((values) => values.chainMap((value) => value
@@ -2482,7 +2343,11 @@ export var PropertyGroup;
         else {
             label = parameters?.label;
         }
-        return { $identifier, $type, comment, label };
+        const $object = { $identifier, $type, comment, label };
+        if (!globalThis.Object.prototype.hasOwnProperty.call($object, "toString")) {
+            $object.toString = $toString;
+        }
+        return $object;
     }
     PropertyGroup.create = create;
     let Identifier;
@@ -2525,43 +2390,46 @@ export var PropertyGroup;
                 }
                 return Left(new Error(`${$resource.identifier} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/ns/shacl#PropertyGroup)`));
             })
-            : Right(true)).chain((_rdfTypeCheck) => 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())
-            .chain(($identifier) => $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(),
-                })),
-        }).chain((comment) => $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(),
-                })),
-        }).map((label) => create({ $identifier, comment, label })))));
+            : 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(),
+                    })),
+            }),
+        }).map((properties) => create(properties)));
     };
     PropertyGroup.fromRdfResource = $wrap_FromRdfResourceFunction(PropertyGroup._fromRdfResource);
     PropertyGroup.fromRdfResourceValues = (values, options) => values.chain((values) => values.chainMap((value) => value
@@ -2717,7 +2585,7 @@ export var Ontology;
         else {
             tsImports = parameters?.tsImports;
         }
-        return {
+        const $object = {
             $identifier,
             $type,
             comment,
@@ -2726,6 +2594,10 @@ export var Ontology;
             tsFeatureIncludes,
             tsImports,
         };
+        if (!globalThis.Object.prototype.hasOwnProperty.call($object, "toString")) {
+            $object.toString = $toString;
+        }
+        return $object;
     }
     Ontology.create = create;
     let Identifier;
@@ -2780,109 +2652,108 @@ export var Ontology;
                 }
                 return Left(new Error(`${$resource.identifier} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/2002/07/owl#Ontology)`));
             })
-            : Right(true)).chain((_rdfTypeCheck) => 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())
-            .chain(($identifier) => $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({
+            : 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(),
+                    })),
+            }),
+            tsFeatureExcludes: $shaclPropertyFromRdf({
+                graph: _$options.graph,
+                resource: $resource,
+                propertySchema: Ontology.schema.properties.tsFeatureExcludes,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .chain((values) => values.chainMap((value) => value.toIri([
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_All"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Create"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_Default"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Equals"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Graphql"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Hash"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Json"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_None"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Rdf"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Sparql"),
+                ])))
+                    .map((values) => values.toArray())
+                    .map((valuesArray) => Resource.Values.fromValue({
                     focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.comment.path,
-                    value: Maybe.empty(),
+                    propertyPath: Ontology.schema.properties.tsFeatureExcludes.path,
+                    value: valuesArray,
                 })),
-        }).chain((comment) => $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({
+            }),
+            tsFeatureIncludes: $shaclPropertyFromRdf({
+                graph: _$options.graph,
+                resource: $resource,
+                propertySchema: Ontology.schema.properties.tsFeatureIncludes,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .chain((values) => values.chainMap((value) => value.toIri([
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_All"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Create"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_Default"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Equals"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Graphql"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Hash"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Json"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_None"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Rdf"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Sparql"),
+                ])))
+                    .map((values) => values.toArray())
+                    .map((valuesArray) => Resource.Values.fromValue({
                     focusResource: $resource,
-                    propertyPath: PropertyShape.schema.properties.label.path,
-                    value: Maybe.empty(),
+                    propertyPath: Ontology.schema.properties.tsFeatureIncludes.path,
+                    value: valuesArray,
                 })),
-        }).chain((label) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: Ontology.schema.properties.tsFeatureExcludes,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toIri([
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_All"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Create"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_Default"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Equals"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Graphql"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Hash"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Json"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_None"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Rdf"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Sparql"),
-            ])))
-                .map((values) => values.toArray())
-                .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $resource,
-                propertyPath: Ontology.schema.properties.tsFeatureExcludes.path,
-                value: valuesArray,
-            })),
-        }).chain((tsFeatureExcludes) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: Ontology.schema.properties.tsFeatureIncludes,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toIri([
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_All"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Create"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_Default"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Equals"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Graphql"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Hash"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Json"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_None"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Rdf"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Sparql"),
-            ])))
-                .map((values) => values.toArray())
-                .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $resource,
-                propertyPath: Ontology.schema.properties.tsFeatureIncludes.path,
-                value: valuesArray,
-            })),
-        }).chain((tsFeatureIncludes) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: Ontology.schema.properties.tsImports,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                .chain((values) => values.chainMap((value) => value.toString()))
-                .map((values) => values.toArray())
-                .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $resource,
-                propertyPath: Ontology.schema.properties.tsImports.path,
-                value: valuesArray,
-            })),
-        }).map((tsImports) => create({
-            $identifier,
-            comment,
-            label,
-            tsFeatureExcludes,
-            tsFeatureIncludes,
-            tsImports,
-        }))))))));
+            }),
+            tsImports: $shaclPropertyFromRdf({
+                graph: _$options.graph,
+                resource: $resource,
+                propertySchema: Ontology.schema.properties.tsImports,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
+                    .chain((values) => values.chainMap((value) => value.toString()))
+                    .map((values) => values.toArray())
+                    .map((valuesArray) => Resource.Values.fromValue({
+                    focusResource: $resource,
+                    propertyPath: Ontology.schema.properties.tsImports.path,
+                    value: valuesArray,
+                })),
+            }),
+        }).map((properties) => create(properties)));
     };
     Ontology.fromRdfResource = $wrap_FromRdfResourceFunction(Ontology._fromRdfResource);
     Ontology.fromRdfResourceValues = (values, options) => values.chain((values) => values.chainMap((value) => value
@@ -3671,7 +3542,7 @@ export var NodeShape;
         else {
             xone = parameters?.xone;
         }
-        return {
+        const $object = {
             $identifier,
             $type,
             and,
@@ -3715,6 +3586,10 @@ export var NodeShape;
             types,
             xone,
         };
+        if (!globalThis.Object.prototype.hasOwnProperty.call($object, "toString")) {
+            $object.toString = $toString;
+        }
+        return $object;
     }
     NodeShape.create = create;
     let Identifier;
@@ -3909,846 +3784,668 @@ export var NodeShape;
                 }
                 return Left(new Error(`${$resource.identifier} has unexpected RDF type (actual: ${actualRdfType.value}, expected: http://www.w3.org/ns/shacl#NodeShape)`));
             })
-            : Right(true)).chain((_rdfTypeCheck) => 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())
-            .chain(($identifier) => $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({
+            : Right(true)).chain((_rdfTypeCheck) => $sequenceRecord({
+            $identifier: Right(new Resource.Value({
+                dataFactory: dataFactory,
                 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({
+                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,
-                    value: Maybe.empty(),
-                })),
-        }).chain((and) => $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,
-            })),
-        }).chain((classes) => $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(),
-                })),
-        }).chain((closed) => $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(),
-                })),
-        }).chain((comment) => $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(),
-                })),
-        }).chain((datatype) => $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(),
-                })),
-        }).chain((deactivated) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: NodeShape.schema.properties.discriminantValue,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                .chain((values) => values.chainMap((value) => value.toString()))
-                .map((values) => values.length > 0
-                ? values.map((value) => Maybe.of(value))
-                : Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: NodeShape.schema.properties
-                        .discriminantValue.path,
-                    value: Maybe.empty(),
-                })),
-        }).chain((discriminantValue) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: NodeShape.schema.properties.extern,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toBoolean()))
-                .map((values) => values.length > 0
-                ? values.map((value) => Maybe.of(value))
-                : Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: NodeShape.schema.properties.extern.path,
-                    value: Maybe.empty(),
-                })),
-        }).chain((extern) => $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,
-            })),
-        }).chain((flags) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: NodeShape.schema.properties.fromRdfType,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toIri()))
-                .map((values) => values.length > 0
-                ? values.map((value) => Maybe.of(value))
-                : Resource.Values.fromValue({
-                    focusResource: $resource,
-                    propertyPath: NodeShape.schema.properties
-                        .fromRdfType.path,
-                    value: Maybe.empty(),
-                })),
-        }).chain((fromRdfType) => $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,
-            })),
-        }).chain((hasValues) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: NodeShape.schema.properties.ignoredProperties,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toList({
+                    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,
-            })))
-                .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({
+                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: NodeShape.schema.properties
-                        .ignoredProperties.path,
-                    value: Maybe.empty(),
+                    propertyPath: PropertyShape.schema.properties.classes.path,
+                    value: valuesArray,
                 })),
-        }).chain((ignoredProperties) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: NodeShape.schema.properties.in_,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toList({
+            }),
+            closed: $shaclPropertyFromRdf({
                 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(),
-                })),
-        }).chain((in_) => $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(),
-                })),
-        }).chain((isDefinedBy) => $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(),
-                })),
-        }).chain((label) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: NodeShape.schema.properties.languageIn,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toList({
+                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,
-            })))
-                .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({
+                resource: $resource,
+                propertySchema: NodeShape.schema.properties.comment,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
+                    .chain((values) => values.chainMap((value) => value.toString()))
+                    .map((values) => values.length > 0
+                    ? values.map((value) => Maybe.of(value))
+                    : Resource.Values.fromValue({
+                        focusResource: $resource,
+                        propertyPath: PropertyShape.schema.properties.comment.path,
+                        value: Maybe.empty(),
+                    })),
+            }),
+            datatype: $shaclPropertyFromRdf({
+                graph: _$options.graph,
+                resource: $resource,
+                propertySchema: NodeShape.schema.properties.datatype,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .chain((values) => values.chainMap((value) => value.toIri()))
+                    .map((values) => values.length > 0
+                    ? values.map((value) => Maybe.of(value))
+                    : Resource.Values.fromValue({
+                        focusResource: $resource,
+                        propertyPath: PropertyShape.schema.properties.datatype.path,
+                        value: Maybe.empty(),
+                    })),
+            }),
+            deactivated: $shaclPropertyFromRdf({
+                graph: _$options.graph,
+                resource: $resource,
+                propertySchema: NodeShape.schema.properties.deactivated,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .chain((values) => values.chainMap((value) => value.toBoolean()))
+                    .map((values) => values.length > 0
+                    ? values.map((value) => Maybe.of(value))
+                    : Resource.Values.fromValue({
+                        focusResource: $resource,
+                        propertyPath: PropertyShape.schema.properties.deactivated.path,
+                        value: Maybe.empty(),
+                    })),
+            }),
+            discriminantValue: $shaclPropertyFromRdf({
+                graph: _$options.graph,
+                resource: $resource,
+                propertySchema: NodeShape.schema.properties.discriminantValue,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
+                    .chain((values) => values.chainMap((value) => value.toString()))
+                    .map((values) => values.length > 0
+                    ? values.map((value) => Maybe.of(value))
+                    : Resource.Values.fromValue({
+                        focusResource: $resource,
+                        propertyPath: NodeShape.schema.properties.discriminantValue.path,
+                        value: Maybe.empty(),
+                    })),
+            }),
+            extern: $shaclPropertyFromRdf({
+                graph: _$options.graph,
+                resource: $resource,
+                propertySchema: NodeShape.schema.properties.extern,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .chain((values) => values.chainMap((value) => value.toBoolean()))
+                    .map((values) => values.length > 0
+                    ? values.map((value) => Maybe.of(value))
+                    : Resource.Values.fromValue({
+                        focusResource: $resource,
+                        propertyPath: NodeShape.schema.properties.extern.path,
+                        value: Maybe.empty(),
+                    })),
+            }),
+            flags: $shaclPropertyFromRdf({
+                graph: _$options.graph,
+                resource: $resource,
+                propertySchema: NodeShape.schema.properties.flags,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
+                    .chain((values) => values.chainMap((value) => value.toString()))
+                    .map((values) => values.toArray())
+                    .map((valuesArray) => Resource.Values.fromValue({
                     focusResource: $resource,
-                    propertyPath: PropertyShape.schema
-                        .properties.languageIn
-                        .path,
-                    value: Maybe.empty(),
+                    propertyPath: PropertyShape.schema.properties.flags.path,
+                    value: valuesArray,
                 })),
-        }).chain((languageIn) => $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({
+            }),
+            fromRdfType: $shaclPropertyFromRdf({
+                graph: _$options.graph,
+                resource: $resource,
+                propertySchema: NodeShape.schema.properties.fromRdfType,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .chain((values) => values.chainMap((value) => value.toIri()))
+                    .map((values) => values.length > 0
+                    ? values.map((value) => Maybe.of(value))
+                    : Resource.Values.fromValue({
+                        focusResource: $resource,
+                        propertyPath: NodeShape.schema.properties.fromRdfType.path,
+                        value: Maybe.empty(),
+                    })),
+            }),
+            hasValues: $shaclPropertyFromRdf({
+                graph: _$options.graph,
+                resource: $resource,
+                propertySchema: NodeShape.schema.properties.hasValues,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .chain((values) => values.chainMap((value) => value.toTerm().chain((term) => {
+                    switch (term.termType) {
+                        case "NamedNode":
+                        case "Literal":
+                            return Either.of(term);
+                        default:
+                            return Left(new Resource.MistypedTermValueError({
+                                actualValue: term,
+                                expectedValueType: "(NamedNode | Literal)",
+                                focusResource: $resource,
+                                propertyPath: PropertyShape.schema.properties.hasValues.path,
+                            }));
+                    }
+                })))
+                    .map((values) => values.toArray())
+                    .map((valuesArray) => Resource.Values.fromValue({
                     focusResource: $resource,
-                    propertyPath: PropertyShape.schema
-                        .properties.maxCount
-                        .path,
-                    value: Maybe.empty(),
+                    propertyPath: PropertyShape.schema.properties.hasValues.path,
+                    value: valuesArray,
                 })),
-        }).chain((maxCount) => $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({
+            }),
+            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: PropertyShape.schema
-                        .properties
-                        .maxExclusive
-                        .path,
-                    value: Maybe.empty(),
-                })),
-        }).chain((maxExclusive) => $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({
+                    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
-                        .maxInclusive
-                        .path,
-                    value: Maybe.empty(),
-                })),
-        }).chain((maxInclusive) => $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({
+                    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
-                        .maxLength
-                        .path,
-                    value: Maybe.empty(),
-                })),
-        }).chain((maxLength) => $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({
+                    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(),
+                    })),
+            }),
+            mutable: $shaclPropertyFromRdf({
+                graph: _$options.graph,
+                resource: $resource,
+                propertySchema: NodeShape.schema.properties.mutable,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .chain((values) => values.chainMap((value) => value.toBoolean()))
+                    .map((values) => values.length > 0
+                    ? values.map((value) => Maybe.of(value))
+                    : Resource.Values.fromValue({
+                        focusResource: $resource,
+                        propertyPath: PropertyShape.schema.properties.mutable.path,
+                        value: Maybe.empty(),
+                    })),
+            }),
+            node: $shaclPropertyFromRdf({
+                graph: _$options.graph,
+                resource: $resource,
+                propertySchema: NodeShape.schema.properties.node,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .chain((values) => values.chainMap((value) => value.toIdentifier()))
+                    .map((values) => values.length > 0
+                    ? values.map((value) => Maybe.of(value))
+                    : Resource.Values.fromValue({
+                        focusResource: $resource,
+                        propertyPath: PropertyShape.schema.properties.node.path,
+                        value: Maybe.empty(),
+                    })),
+            }),
+            nodeKind: $shaclPropertyFromRdf({
+                graph: _$options.graph,
+                resource: $resource,
+                propertySchema: NodeShape.schema.properties.nodeKind,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .chain((values) => values.chainMap((value) => value.toIri([
+                    dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNode"),
+                    dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNodeOrIRI"),
+                    dataFactory.namedNode("http://www.w3.org/ns/shacl#BlankNodeOrLiteral"),
+                    dataFactory.namedNode("http://www.w3.org/ns/shacl#IRI"),
+                    dataFactory.namedNode("http://www.w3.org/ns/shacl#IRIOrLiteral"),
+                    dataFactory.namedNode("http://www.w3.org/ns/shacl#Literal"),
+                ])))
+                    .map((values) => values.length > 0
+                    ? values.map((value) => Maybe.of(value))
+                    : Resource.Values.fromValue({
+                        focusResource: $resource,
+                        propertyPath: PropertyShape.schema.properties.nodeKind.path,
+                        value: Maybe.empty(),
+                    })),
+            }),
+            not: $shaclPropertyFromRdf({
+                graph: _$options.graph,
+                resource: $resource,
+                propertySchema: NodeShape.schema.properties.not,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .chain((values) => values.chainMap((value) => value.toIdentifier()))
+                    .map((values) => values.toArray())
+                    .map((valuesArray) => Resource.Values.fromValue({
                     focusResource: $resource,
-                    propertyPath: PropertyShape
-                        .schema
-                        .properties
-                        .minCount
-                        .path,
-                    value: Maybe.empty(),
+                    propertyPath: PropertyShape.schema.properties.not.path,
+                    value: valuesArray,
                 })),
-        }).chain((minCount) => $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({
+            }),
+            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
-                        .minExclusive
-                        .path,
-                    value: Maybe.empty(),
-                })),
-        }).chain((minExclusive) => $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({
+                    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
-                        .minInclusive
-                        .path,
-                    value: Maybe.empty(),
+                    propertyPath: PropertyShape.schema.properties.patterns.path,
+                    value: valuesArray,
                 })),
-        }).chain((minInclusive) => $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({
+            }),
+            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: PropertyShape
-                        .schema
-                        .properties
-                        .minLength
-                        .path,
-                    value: Maybe.empty(),
+                    propertyPath: NodeShape.schema.properties.properties.path,
+                    value: valuesArray,
                 })),
-        }).chain((minLength) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: NodeShape.schema
-                .properties
-                .mutable,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toBoolean()))
-                .map((values) => values.length >
-                0
-                ? values.map((value) => Maybe.of(value))
-                : Resource.Values.fromValue({
+            }),
+            rdfType: $shaclPropertyFromRdf({
+                graph: _$options.graph,
+                resource: $resource,
+                propertySchema: NodeShape.schema.properties.rdfType,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .chain((values) => values.chainMap((value) => value.toIri()))
+                    .map((values) => values.length > 0
+                    ? values.map((value) => Maybe.of(value))
+                    : Resource.Values.fromValue({
+                        focusResource: $resource,
+                        propertyPath: NodeShape.schema.properties.rdfType.path,
+                        value: Maybe.empty(),
+                    })),
+            }),
+            shaclmateName: $shaclPropertyFromRdf({
+                graph: _$options.graph,
+                resource: $resource,
+                propertySchema: NodeShape.schema.properties.shaclmateName,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
+                    .chain((values) => values.chainMap((value) => value.toString()))
+                    .map((values) => values.length > 0
+                    ? values.map((value) => Maybe.of(value))
+                    : Resource.Values.fromValue({
+                        focusResource: $resource,
+                        propertyPath: PropertyShape.schema.properties.shaclmateName.path,
+                        value: Maybe.empty(),
+                    })),
+            }),
+            subClassOf: $shaclPropertyFromRdf({
+                graph: _$options.graph,
+                resource: $resource,
+                propertySchema: NodeShape.schema.properties.subClassOf,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .chain((values) => values.chainMap((value) => value.toIri()))
+                    .map((values) => values.toArray())
+                    .map((valuesArray) => Resource.Values.fromValue({
                     focusResource: $resource,
-                    propertyPath: PropertyShape
-                        .schema
-                        .properties
-                        .mutable
-                        .path,
-                    value: Maybe.empty(),
+                    propertyPath: NodeShape.schema.properties.subClassOf.path,
+                    value: valuesArray,
                 })),
-        }).chain((mutable) => $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({
+            }),
+            toRdfTypes: $shaclPropertyFromRdf({
+                graph: _$options.graph,
+                resource: $resource,
+                propertySchema: NodeShape.schema.properties.toRdfTypes,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .chain((values) => values.chainMap((value) => value.toIri()))
+                    .map((values) => values.toArray())
+                    .map((valuesArray) => Resource.Values.fromValue({
                     focusResource: $resource,
-                    propertyPath: PropertyShape
-                        .schema
-                        .properties
-                        .node
-                        .path,
-                    value: Maybe.empty(),
+                    propertyPath: NodeShape.schema.properties.toRdfTypes.path,
+                    value: valuesArray,
                 })),
-        }).chain((node) => $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({
+            }),
+            tsFeatureExcludes: $shaclPropertyFromRdf({
+                graph: _$options.graph,
+                resource: $resource,
+                propertySchema: NodeShape.schema.properties.tsFeatureExcludes,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .chain((values) => values.chainMap((value) => value.toIri([
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_All"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Create"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_Default"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Equals"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Graphql"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Hash"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Json"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_None"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Rdf"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Sparql"),
+                ])))
+                    .map((values) => values.toArray())
+                    .map((valuesArray) => Resource.Values.fromValue({
                     focusResource: $resource,
-                    propertyPath: PropertyShape
-                        .schema
-                        .properties
-                        .nodeKind
-                        .path,
-                    value: Maybe.empty(),
+                    propertyPath: Ontology.schema.properties.tsFeatureExcludes.path,
+                    value: valuesArray,
                 })),
-        }).chain((nodeKind) => $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,
-            })),
-        }).chain((not) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: NodeShape.schema
-                .properties
-                .or,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toList({
+            }),
+            tsFeatureIncludes: $shaclPropertyFromRdf({
                 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({
+                resource: $resource,
+                propertySchema: NodeShape.schema.properties.tsFeatureIncludes,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .chain((values) => values.chainMap((value) => value.toIri([
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_All"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Create"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_Default"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Equals"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Graphql"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Hash"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Json"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_None"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Rdf"),
+                    dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Sparql"),
+                ])))
+                    .map((values) => values.toArray())
+                    .map((valuesArray) => Resource.Values.fromValue({
                     focusResource: $resource,
-                    propertyPath: PropertyShape
-                        .schema
-                        .properties
-                        .or
-                        .path,
-                    value: Maybe.empty(),
+                    propertyPath: Ontology.schema.properties.tsFeatureIncludes.path,
+                    value: valuesArray,
                 })),
-        }).chain((or) => $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,
-            })),
-        }).chain((patterns) => $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,
-            })),
-        }).chain((properties) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: NodeShape.schema
-                .properties
-                .rdfType,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toIri()))
-                .map((values) => values.length >
-                0
-                ? values.map((value) => Maybe.of(value))
-                : Resource.Values.fromValue({
+            }),
+            tsImports: $shaclPropertyFromRdf({
+                graph: _$options.graph,
+                resource: $resource,
+                propertySchema: NodeShape.schema.properties.tsImports,
+                typeFromRdf: (resourceValues) => resourceValues
+                    .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
+                    .chain((values) => values.chainMap((value) => value.toString()))
+                    .map((values) => values.toArray())
+                    .map((valuesArray) => Resource.Values.fromValue({
                     focusResource: $resource,
-                    propertyPath: NodeShape
-                        .schema
-                        .properties
-                        .rdfType
-                        .path,
-                    value: Maybe.empty(),
+                    propertyPath: Ontology.schema.properties.tsImports.path,
+                    value: valuesArray,
                 })),
-        }).chain((rdfType) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: NodeShape.schema
-                .properties
-                .shaclmateName,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                .chain((values) => values.chainMap((value) => value.toString()))
-                .map((values) => values.length >
-                0
-                ? values.map((value) => Maybe.of(value))
-                : Resource.Values.fromValue({
+            }),
+            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: PropertyShape
-                        .schema
-                        .properties
-                        .shaclmateName
-                        .path,
-                    value: Maybe.empty(),
+                    propertyPath: NodeShape.schema.properties.types.path,
+                    value: valuesArray,
                 })),
-        }).chain((shaclmateName) => $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,
-            })),
-        }).chain((subClassOf) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: NodeShape.schema
-                .properties
-                .toRdfTypes,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toIri()))
-                .map((values) => values.toArray())
-                .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $resource,
-                propertyPath: NodeShape
-                    .schema
-                    .properties
-                    .toRdfTypes
-                    .path,
-                value: valuesArray,
-            })),
-        }).chain((toRdfTypes) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: NodeShape.schema
-                .properties
-                .tsFeatureExcludes,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toIri([
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_All"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Create"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_Default"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Equals"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Graphql"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Hash"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Json"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_None"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Rdf"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Sparql"),
-            ])))
-                .map((values) => values.toArray())
-                .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $resource,
-                propertyPath: Ontology
-                    .schema
-                    .properties
-                    .tsFeatureExcludes
-                    .path,
-                value: valuesArray,
-            })),
-        }).chain((tsFeatureExcludes) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: NodeShape.schema
-                .properties
-                .tsFeatureIncludes,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toIri([
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_All"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Create"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_Default"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Equals"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Graphql"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Hash"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Json"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeatures_None"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Rdf"),
-                dataFactory.namedNode("http://purl.org/shaclmate/ontology#_TsFeature_Sparql"),
-            ])))
-                .map((values) => values.toArray())
-                .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $resource,
-                propertyPath: Ontology
-                    .schema
-                    .properties
-                    .tsFeatureIncludes
-                    .path,
-                value: valuesArray,
-            })),
-        }).chain((tsFeatureIncludes) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: NodeShape.schema
-                .properties
-                .tsImports,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => $fromRdfPreferredLanguages(values, _$options.preferredLanguages))
-                .chain((values) => values.chainMap((value) => value.toString()))
-                .map((values) => values.toArray())
-                .map((valuesArray) => Resource.Values.fromValue({
-                focusResource: $resource,
-                propertyPath: Ontology
-                    .schema
-                    .properties
-                    .tsImports
-                    .path,
-                value: valuesArray,
-            })),
-        }).chain((tsImports) => $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,
-            })),
-        }).chain((types) => $shaclPropertyFromRdf({
-            graph: _$options.graph,
-            resource: $resource,
-            propertySchema: NodeShape.schema
-                .properties
-                .xone,
-            typeFromRdf: (resourceValues) => resourceValues
-                .chain((values) => values.chainMap((value) => value.toList({
+            }),
+            xone: $shaclPropertyFromRdf({
                 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({
+                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,
-                    value: Maybe.empty(),
-                })),
-        }).map((xone) => create({
-            $identifier,
-            and,
-            classes,
-            closed,
-            comment,
-            datatype,
-            deactivated,
-            discriminantValue,
-            extern,
-            flags,
-            fromRdfType,
-            hasValues,
-            ignoredProperties,
-            in_,
-            isDefinedBy,
-            label,
-            languageIn,
-            maxCount,
-            maxExclusive,
-            maxInclusive,
-            maxLength,
-            minCount,
-            minExclusive,
-            minInclusive,
-            minLength,
-            mutable,
-            node,
-            nodeKind,
-            not,
-            or,
-            patterns,
-            properties,
-            rdfType,
-            shaclmateName,
-            subClassOf,
-            toRdfTypes,
-            tsFeatureExcludes,
-            tsFeatureIncludes,
-            tsImports,
-            types,
-            xone,
-        })))))))))))))))))))))))))))))))))))))))))));
+                    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(),
+                    })),
+            }),
+        }).map((properties) => create(properties)));
     };
     NodeShape.fromRdfResource = $wrap_FromRdfResourceFunction(NodeShape._fromRdfResource);
     NodeShape.fromRdfResourceValues = (values, options) => values.chain((values) => values.chainMap((value) => value